home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1998 July / EnigmA AMIGA RUN 29 (1998)(G.R. Edizioni)(IT)[!][issue 1998-07 & 08].iso / earcd / phase5 / ppcrelease / fd2inline / include / ppcpragmas / dos_pragmas.h < prev    next >
C/C++ Source or Header  |  1998-02-21  |  85KB  |  3,093 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_DOS_H
  4. #define _PPCPRAGMA_DOS_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__DOS_H
  7. #include <powerup/ppcinline/dos.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef DOS_BASE_NAME
  24. #define DOS_BASE_NAME DOSBase
  25. #endif /* !DOS_BASE_NAME */
  26.  
  27. #define    AbortPkt(port, pkt)    _AbortPkt(DOS_BASE_NAME, port, pkt)
  28.  
  29. static __inline void
  30. _AbortPkt(void *DOSBase, struct MsgPort *port, struct DosPacket *pkt)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.d1        =(ULONG) port;
  40.     MyCaos.d2        =(ULONG) pkt;
  41.     MyCaos.caos_Un.Offset    =    (-264);
  42.     MyCaos.a6        =(ULONG) DOSBase;    
  43.     PPCCallOS(&MyCaos);
  44. }
  45.  
  46. #define    AddBuffers(name, number)    _AddBuffers(DOS_BASE_NAME, name, number)
  47.  
  48. static __inline LONG
  49. _AddBuffers(void *DOSBase, STRPTR name, long number)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.d1        =(ULONG) name;
  59.     MyCaos.d2        =(ULONG) number;
  60.     MyCaos.caos_Un.Offset    =    (-732);
  61.     MyCaos.a6        =(ULONG) DOSBase;    
  62.     return((LONG)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #define    AddDosEntry(dlist)    _AddDosEntry(DOS_BASE_NAME, dlist)
  66.  
  67. static __inline LONG
  68. _AddDosEntry(void *DOSBase, struct DosList *dlist)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.d1        =(ULONG) dlist;
  78.     MyCaos.caos_Un.Offset    =    (-678);
  79.     MyCaos.a6        =(ULONG) DOSBase;    
  80.     return((LONG)PPCCallOS(&MyCaos));
  81. }
  82.  
  83. #define    AddPart(dirname, filename, size)    _AddPart(DOS_BASE_NAME, dirname, filename, size)
  84.  
  85. static __inline BOOL
  86. _AddPart(void *DOSBase, STRPTR dirname, STRPTR filename, unsigned long size)
  87. {
  88. struct Caos    MyCaos;
  89.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  90. //    MyCaos.M68kStart    =    NULL;
  91. //    MyCaos.M68kSize        =    0;
  92.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  93. //    MyCaos.PPCStart        =    NULL;
  94. //    MyCaos.PPCSize        =    0;
  95.     MyCaos.d1        =(ULONG) dirname;
  96.     MyCaos.d2        =(ULONG) filename;
  97.     MyCaos.d3        =(ULONG) size;
  98.     MyCaos.caos_Un.Offset    =    (-882);
  99.     MyCaos.a6        =(ULONG) DOSBase;    
  100.     return((BOOL)PPCCallOS(&MyCaos));
  101. }
  102.  
  103. #define    AddSegment(name, seg, system)    _AddSegment(DOS_BASE_NAME, name, seg, system)
  104.  
  105. static __inline LONG
  106. _AddSegment(void *DOSBase, STRPTR name, BPTR seg, long system)
  107. {
  108. struct Caos    MyCaos;
  109.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  110. //    MyCaos.M68kStart    =    NULL;
  111. //    MyCaos.M68kSize        =    0;
  112.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  113. //    MyCaos.PPCStart        =    NULL;
  114. //    MyCaos.PPCSize        =    0;
  115.     MyCaos.d1        =(ULONG) name;
  116.     MyCaos.d2        =(ULONG) seg;
  117.     MyCaos.d3        =(ULONG) system;
  118.     MyCaos.caos_Un.Offset    =    (-774);
  119.     MyCaos.a6        =(ULONG) DOSBase;    
  120.     return((LONG)PPCCallOS(&MyCaos));
  121. }
  122.  
  123. #define    AllocDosObject(type, tags)    _AllocDosObject(DOS_BASE_NAME, type, tags)
  124.  
  125. static __inline APTR
  126. _AllocDosObject(void *DOSBase, unsigned long type, struct TagItem *tags)
  127. {
  128. struct Caos    MyCaos;
  129.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  130. //    MyCaos.M68kStart    =    NULL;
  131. //    MyCaos.M68kSize        =    0;
  132.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  133. //    MyCaos.PPCStart        =    NULL;
  134. //    MyCaos.PPCSize        =    0;
  135.     MyCaos.d1        =(ULONG) type;
  136.     MyCaos.d2        =(ULONG) tags;
  137.     MyCaos.caos_Un.Offset    =    (-228);
  138.     MyCaos.a6        =(ULONG) DOSBase;    
  139.     return((APTR)PPCCallOS(&MyCaos));
  140. }
  141.  
  142. #define AllocDosObjectTagList(a0, a1) AllocDosObject ((a0), (a1))
  143.  
  144. #ifndef NO_PPCINLINE_STDARG
  145. #define AllocDosObjectTags(a0, tags...) \
  146.     ({ULONG _tags[] = { tags }; AllocDosObject((a0), (struct TagItem *)_tags);})
  147. #endif /* !NO_PPCINLINE_STDARG */
  148.  
  149. #define    AssignAdd(name, lock)    _AssignAdd(DOS_BASE_NAME, name, lock)
  150.  
  151. static __inline BOOL
  152. _AssignAdd(void *DOSBase, STRPTR name, BPTR lock)
  153. {
  154. struct Caos    MyCaos;
  155.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  156. //    MyCaos.M68kStart    =    NULL;
  157. //    MyCaos.M68kSize        =    0;
  158.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  159. //    MyCaos.PPCStart        =    NULL;
  160. //    MyCaos.PPCSize        =    0;
  161.     MyCaos.d1        =(ULONG) name;
  162.     MyCaos.d2        =(ULONG) lock;
  163.     MyCaos.caos_Un.Offset    =    (-630);
  164.     MyCaos.a6        =(ULONG) DOSBase;    
  165.     return((BOOL)PPCCallOS(&MyCaos));
  166. }
  167.  
  168. #define    AssignLate(name, path)    _AssignLate(DOS_BASE_NAME, name, path)
  169.  
  170. static __inline BOOL
  171. _AssignLate(void *DOSBase, STRPTR name, STRPTR path)
  172. {
  173. struct Caos    MyCaos;
  174.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  175. //    MyCaos.M68kStart    =    NULL;
  176. //    MyCaos.M68kSize        =    0;
  177.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  178. //    MyCaos.PPCStart        =    NULL;
  179. //    MyCaos.PPCSize        =    0;
  180.     MyCaos.d1        =(ULONG) name;
  181.     MyCaos.d2        =(ULONG) path;
  182.     MyCaos.caos_Un.Offset    =    (-618);
  183.     MyCaos.a6        =(ULONG) DOSBase;    
  184.     return((BOOL)PPCCallOS(&MyCaos));
  185. }
  186.  
  187. #define    AssignLock(name, lock)    _AssignLock(DOS_BASE_NAME, name, lock)
  188.  
  189. static __inline LONG
  190. _AssignLock(void *DOSBase, STRPTR name, BPTR lock)
  191. {
  192. struct Caos    MyCaos;
  193.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  194. //    MyCaos.M68kStart    =    NULL;
  195. //    MyCaos.M68kSize        =    0;
  196.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  197. //    MyCaos.PPCStart        =    NULL;
  198. //    MyCaos.PPCSize        =    0;
  199.     MyCaos.d1        =(ULONG) name;
  200.     MyCaos.d2        =(ULONG) lock;
  201.     MyCaos.caos_Un.Offset    =    (-612);
  202.     MyCaos.a6        =(ULONG) DOSBase;    
  203.     return((LONG)PPCCallOS(&MyCaos));
  204. }
  205.  
  206. #define    AssignPath(name, path)    _AssignPath(DOS_BASE_NAME, name, path)
  207.  
  208. static __inline BOOL
  209. _AssignPath(void *DOSBase, STRPTR name, STRPTR path)
  210. {
  211. struct Caos    MyCaos;
  212.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  213. //    MyCaos.M68kStart    =    NULL;
  214. //    MyCaos.M68kSize        =    0;
  215.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  216. //    MyCaos.PPCStart        =    NULL;
  217. //    MyCaos.PPCSize        =    0;
  218.     MyCaos.d1        =(ULONG) name;
  219.     MyCaos.d2        =(ULONG) path;
  220.     MyCaos.caos_Un.Offset    =    (-624);
  221.     MyCaos.a6        =(ULONG) DOSBase;    
  222.     return((BOOL)PPCCallOS(&MyCaos));
  223. }
  224.  
  225. #define    AttemptLockDosList(flags)    _AttemptLockDosList(DOS_BASE_NAME, flags)
  226.  
  227. static __inline struct DosList *
  228. _AttemptLockDosList(void *DOSBase, unsigned long flags)
  229. {
  230. struct Caos    MyCaos;
  231.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  232. //    MyCaos.M68kStart    =    NULL;
  233. //    MyCaos.M68kSize        =    0;
  234.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  235. //    MyCaos.PPCStart        =    NULL;
  236. //    MyCaos.PPCSize        =    0;
  237.     MyCaos.d1        =(ULONG) flags;
  238.     MyCaos.caos_Un.Offset    =    (-666);
  239.     MyCaos.a6        =(ULONG) DOSBase;    
  240.     return((struct DosList *)PPCCallOS(&MyCaos));
  241. }
  242.  
  243. #define    ChangeMode(type, fh, newmode)    _ChangeMode(DOS_BASE_NAME, type, fh, newmode)
  244.  
  245. static __inline LONG
  246. _ChangeMode(void *DOSBase, long type, BPTR fh, long newmode)
  247. {
  248. struct Caos    MyCaos;
  249.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  250. //    MyCaos.M68kStart    =    NULL;
  251. //    MyCaos.M68kSize        =    0;
  252.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  253. //    MyCaos.PPCStart        =    NULL;
  254. //    MyCaos.PPCSize        =    0;
  255.     MyCaos.d1        =(ULONG) type;
  256.     MyCaos.d2        =(ULONG) fh;
  257.     MyCaos.d3        =(ULONG) newmode;
  258.     MyCaos.caos_Un.Offset    =    (-450);
  259.     MyCaos.a6        =(ULONG) DOSBase;    
  260.     return((LONG)PPCCallOS(&MyCaos));
  261. }
  262.  
  263. #define    CheckSignal(mask)    _CheckSignal(DOS_BASE_NAME, mask)
  264.  
  265. static __inline LONG
  266. _CheckSignal(void *DOSBase, long mask)
  267. {
  268. struct Caos    MyCaos;
  269.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  270. //    MyCaos.M68kStart    =    NULL;
  271. //    MyCaos.M68kSize        =    0;
  272.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.PPCStart        =    NULL;
  274. //    MyCaos.PPCSize        =    0;
  275.     MyCaos.d1        =(ULONG) mask;
  276.     MyCaos.caos_Un.Offset    =    (-792);
  277.     MyCaos.a6        =(ULONG) DOSBase;    
  278.     return((LONG)PPCCallOS(&MyCaos));
  279. }
  280.  
  281. #define    Cli()    _Cli(DOS_BASE_NAME)
  282.  
  283. static __inline struct CommandLineInterface *
  284. _Cli(void *DOSBase)
  285. {
  286. struct Caos    MyCaos;
  287.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  288. //    MyCaos.M68kStart    =    NULL;
  289. //    MyCaos.M68kSize        =    0;
  290.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  291. //    MyCaos.PPCStart        =    NULL;
  292. //    MyCaos.PPCSize        =    0;
  293.     MyCaos.caos_Un.Offset    =    (-492);
  294.     MyCaos.a6        =(ULONG) DOSBase;    
  295.     return((struct CommandLineInterface *)PPCCallOS(&MyCaos));
  296. }
  297.  
  298. #define    CliInitNewcli(dp)    _CliInitNewcli(DOS_BASE_NAME, dp)
  299.  
  300. static __inline LONG
  301. _CliInitNewcli(void *DOSBase, struct DosPacket *dp)
  302. {
  303. struct Caos    MyCaos;
  304.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  305. //    MyCaos.M68kStart    =    NULL;
  306. //    MyCaos.M68kSize        =    0;
  307.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  308. //    MyCaos.PPCStart        =    NULL;
  309. //    MyCaos.PPCSize        =    0;
  310.     MyCaos.a0        =(ULONG) dp;
  311.     MyCaos.caos_Un.Offset    =    (-930);
  312.     MyCaos.a6        =(ULONG) DOSBase;    
  313.     return((LONG)PPCCallOS(&MyCaos));
  314. }
  315.  
  316. #define    CliInitRun(dp)    _CliInitRun(DOS_BASE_NAME, dp)
  317.  
  318. static __inline LONG
  319. _CliInitRun(void *DOSBase, struct DosPacket *dp)
  320. {
  321. struct Caos    MyCaos;
  322.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  323. //    MyCaos.M68kStart    =    NULL;
  324. //    MyCaos.M68kSize        =    0;
  325.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  326. //    MyCaos.PPCStart        =    NULL;
  327. //    MyCaos.PPCSize        =    0;
  328.     MyCaos.a0        =(ULONG) dp;
  329.     MyCaos.caos_Un.Offset    =    (-936);
  330.     MyCaos.a6        =(ULONG) DOSBase;    
  331.     return((LONG)PPCCallOS(&MyCaos));
  332. }
  333.  
  334. #define    Close(file)    _Close(DOS_BASE_NAME, file)
  335.  
  336. static __inline LONG
  337. _Close(void *DOSBase, BPTR file)
  338. {
  339. struct Caos    MyCaos;
  340.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  341. //    MyCaos.M68kStart    =    NULL;
  342. //    MyCaos.M68kSize        =    0;
  343.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  344. //    MyCaos.PPCStart        =    NULL;
  345. //    MyCaos.PPCSize        =    0;
  346.     MyCaos.d1        =(ULONG) file;
  347.     MyCaos.caos_Un.Offset    =    (-36);
  348.     MyCaos.a6        =(ULONG) DOSBase;    
  349.     return((LONG)PPCCallOS(&MyCaos));
  350. }
  351.  
  352. #define    CompareDates(date1, date2)    _CompareDates(DOS_BASE_NAME, date1, date2)
  353.  
  354. static __inline LONG
  355. _CompareDates(void *DOSBase, struct DateStamp *date1, struct DateStamp *date2)
  356. {
  357. struct Caos    MyCaos;
  358.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  359. //    MyCaos.M68kStart    =    NULL;
  360. //    MyCaos.M68kSize        =    0;
  361.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  362. //    MyCaos.PPCStart        =    NULL;
  363. //    MyCaos.PPCSize        =    0;
  364.     MyCaos.d1        =(ULONG) date1;
  365.     MyCaos.d2        =(ULONG) date2;
  366.     MyCaos.caos_Un.Offset    =    (-738);
  367.     MyCaos.a6        =(ULONG) DOSBase;    
  368.     return((LONG)PPCCallOS(&MyCaos));
  369. }
  370.  
  371. #define    CreateDir(name)    _CreateDir(DOS_BASE_NAME, name)
  372.  
  373. static __inline BPTR
  374. _CreateDir(void *DOSBase, STRPTR name)
  375. {
  376. struct Caos    MyCaos;
  377.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  378. //    MyCaos.M68kStart    =    NULL;
  379. //    MyCaos.M68kSize        =    0;
  380.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  381. //    MyCaos.PPCStart        =    NULL;
  382. //    MyCaos.PPCSize        =    0;
  383.     MyCaos.d1        =(ULONG) name;
  384.     MyCaos.caos_Un.Offset    =    (-120);
  385.     MyCaos.a6        =(ULONG) DOSBase;    
  386.     return((BPTR)PPCCallOS(&MyCaos));
  387. }
  388.  
  389. #define    CreateNewProc(tags)    _CreateNewProc(DOS_BASE_NAME, tags)
  390.  
  391. static __inline struct Process *
  392. _CreateNewProc(void *DOSBase, struct TagItem *tags)
  393. {
  394. struct Caos    MyCaos;
  395.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  396. //    MyCaos.M68kStart    =    NULL;
  397. //    MyCaos.M68kSize        =    0;
  398.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  399. //    MyCaos.PPCStart        =    NULL;
  400. //    MyCaos.PPCSize        =    0;
  401.     MyCaos.d1        =(ULONG) tags;
  402.     MyCaos.caos_Un.Offset    =    (-498);
  403.     MyCaos.a6        =(ULONG) DOSBase;    
  404.     return((struct Process *)PPCCallOS(&MyCaos));
  405. }
  406.  
  407. #define CreateNewProcTagList(a0) CreateNewProc ((a0))
  408.  
  409. #ifndef NO_PPCINLINE_STDARG
  410. #define CreateNewProcTags(tags...) \
  411.     ({ULONG _tags[] = { tags }; CreateNewProc((struct TagItem *)_tags);})
  412. #endif /* !NO_PPCINLINE_STDARG */
  413.  
  414. #define    CreateProc(name, pri, segList, stackSize)    _CreateProc(DOS_BASE_NAME, name, pri, segList, stackSize)
  415.  
  416. static __inline struct MsgPort *
  417. _CreateProc(void *DOSBase, STRPTR name, long pri, BPTR segList, long stackSize)
  418. {
  419. struct Caos    MyCaos;
  420.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  421. //    MyCaos.M68kStart    =    NULL;
  422. //    MyCaos.M68kSize        =    0;
  423.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  424. //    MyCaos.PPCStart        =    NULL;
  425. //    MyCaos.PPCSize        =    0;
  426.     MyCaos.d1        =(ULONG) name;
  427.     MyCaos.d2        =(ULONG) pri;
  428.     MyCaos.d3        =(ULONG) segList;
  429.     MyCaos.d4        =(ULONG) stackSize;
  430.     MyCaos.caos_Un.Offset    =    (-138);
  431.     MyCaos.a6        =(ULONG) DOSBase;    
  432.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  433. }
  434.  
  435. #define    CurrentDir(lock)    _CurrentDir(DOS_BASE_NAME, lock)
  436.  
  437. static __inline BPTR
  438. _CurrentDir(void *DOSBase, BPTR lock)
  439. {
  440. struct Caos    MyCaos;
  441.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  442. //    MyCaos.M68kStart    =    NULL;
  443. //    MyCaos.M68kSize        =    0;
  444.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  445. //    MyCaos.PPCStart        =    NULL;
  446. //    MyCaos.PPCSize        =    0;
  447.     MyCaos.d1        =(ULONG) lock;
  448.     MyCaos.caos_Un.Offset    =    (-126);
  449.     MyCaos.a6        =(ULONG) DOSBase;    
  450.     return((BPTR)PPCCallOS(&MyCaos));
  451. }
  452.  
  453. #define    DateStamp(date)    _DateStamp(DOS_BASE_NAME, date)
  454.  
  455. static __inline struct DateStamp *
  456. _DateStamp(void *DOSBase, struct DateStamp *date)
  457. {
  458. struct Caos    MyCaos;
  459.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  460. //    MyCaos.M68kStart    =    NULL;
  461. //    MyCaos.M68kSize        =    0;
  462.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  463. //    MyCaos.PPCStart        =    NULL;
  464. //    MyCaos.PPCSize        =    0;
  465.     MyCaos.d1        =(ULONG) date;
  466.     MyCaos.caos_Un.Offset    =    (-192);
  467.     MyCaos.a6        =(ULONG) DOSBase;    
  468.     return((struct DateStamp *)PPCCallOS(&MyCaos));
  469. }
  470.  
  471. #define    DateToStr(datetime)    _DateToStr(DOS_BASE_NAME, datetime)
  472.  
  473. static __inline LONG
  474. _DateToStr(void *DOSBase, struct DateTime *datetime)
  475. {
  476. struct Caos    MyCaos;
  477.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  478. //    MyCaos.M68kStart    =    NULL;
  479. //    MyCaos.M68kSize        =    0;
  480.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  481. //    MyCaos.PPCStart        =    NULL;
  482. //    MyCaos.PPCSize        =    0;
  483.     MyCaos.d1        =(ULONG) datetime;
  484.     MyCaos.caos_Un.Offset    =    (-744);
  485.     MyCaos.a6        =(ULONG) DOSBase;    
  486.     return((LONG)PPCCallOS(&MyCaos));
  487. }
  488.  
  489. #define    Delay(timeout)    _Delay(DOS_BASE_NAME, timeout)
  490.  
  491. static __inline void
  492. _Delay(void *DOSBase, long timeout)
  493. {
  494. struct Caos    MyCaos;
  495.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  496. //    MyCaos.M68kStart    =    NULL;
  497. //    MyCaos.M68kSize        =    0;
  498.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  499. //    MyCaos.PPCStart        =    NULL;
  500. //    MyCaos.PPCSize        =    0;
  501.     MyCaos.d1        =(ULONG) timeout;
  502.     MyCaos.caos_Un.Offset    =    (-198);
  503.     MyCaos.a6        =(ULONG) DOSBase;    
  504.     PPCCallOS(&MyCaos);
  505. }
  506.  
  507. #define    DeleteFile(name)    _DeleteFile(DOS_BASE_NAME, name)
  508.  
  509. static __inline LONG
  510. _DeleteFile(void *DOSBase, STRPTR name)
  511. {
  512. struct Caos    MyCaos;
  513.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  514. //    MyCaos.M68kStart    =    NULL;
  515. //    MyCaos.M68kSize        =    0;
  516.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  517. //    MyCaos.PPCStart        =    NULL;
  518. //    MyCaos.PPCSize        =    0;
  519.     MyCaos.d1        =(ULONG) name;
  520.     MyCaos.caos_Un.Offset    =    (-72);
  521.     MyCaos.a6        =(ULONG) DOSBase;    
  522.     return((LONG)PPCCallOS(&MyCaos));
  523. }
  524.  
  525. #define    DeleteVar(name, flags)    _DeleteVar(DOS_BASE_NAME, name, flags)
  526.  
  527. static __inline LONG
  528. _DeleteVar(void *DOSBase, STRPTR name, unsigned long flags)
  529. {
  530. struct Caos    MyCaos;
  531.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  532. //    MyCaos.M68kStart    =    NULL;
  533. //    MyCaos.M68kSize        =    0;
  534.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  535. //    MyCaos.PPCStart        =    NULL;
  536. //    MyCaos.PPCSize        =    0;
  537.     MyCaos.d1        =(ULONG) name;
  538.     MyCaos.d2        =(ULONG) flags;
  539.     MyCaos.caos_Un.Offset    =    (-912);
  540.     MyCaos.a6        =(ULONG) DOSBase;    
  541.     return((LONG)PPCCallOS(&MyCaos));
  542. }
  543.  
  544. #define    DeviceProc(name)    _DeviceProc(DOS_BASE_NAME, name)
  545.  
  546. static __inline struct MsgPort *
  547. _DeviceProc(void *DOSBase, STRPTR name)
  548. {
  549. struct Caos    MyCaos;
  550.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  551. //    MyCaos.M68kStart    =    NULL;
  552. //    MyCaos.M68kSize        =    0;
  553.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  554. //    MyCaos.PPCStart        =    NULL;
  555. //    MyCaos.PPCSize        =    0;
  556.     MyCaos.d1        =(ULONG) name;
  557.     MyCaos.caos_Un.Offset    =    (-174);
  558.     MyCaos.a6        =(ULONG) DOSBase;    
  559.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  560. }
  561.  
  562. #define    DoPkt(port, action, arg1, arg2, arg3, arg4, arg5)    _DoPkt(DOS_BASE_NAME, port, action, arg1, arg2, arg3, arg4, arg5)
  563.  
  564. static __inline LONG
  565. _DoPkt(void *DOSBase, struct MsgPort *port, long action, long arg1, long arg2, long arg3, long arg4, long arg5)
  566. {
  567. struct Caos    MyCaos;
  568.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  569. //    MyCaos.M68kStart    =    NULL;
  570. //    MyCaos.M68kSize        =    0;
  571.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  572. //    MyCaos.PPCStart        =    NULL;
  573. //    MyCaos.PPCSize        =    0;
  574.     MyCaos.d1        =(ULONG) port;
  575.     MyCaos.d2        =(ULONG) action;
  576.     MyCaos.d3        =(ULONG) arg1;
  577.     MyCaos.d4        =(ULONG) arg2;
  578.     MyCaos.d5        =(ULONG) arg3;
  579.     MyCaos.d6        =(ULONG) arg4;
  580.     MyCaos.d7        =(ULONG) arg5;
  581.     MyCaos.caos_Un.Offset    =    (-240);
  582.     MyCaos.a6        =(ULONG) DOSBase;    
  583.     return((LONG)PPCCallOS(&MyCaos));
  584. }
  585.  
  586. #define    DoPkt0(port, action)    _DoPkt0(DOS_BASE_NAME, port, action)
  587.  
  588. static __inline LONG
  589. _DoPkt0(void *DOSBase, struct MsgPort *port, long action)
  590. {
  591. struct Caos    MyCaos;
  592.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  593. //    MyCaos.M68kStart    =    NULL;
  594. //    MyCaos.M68kSize        =    0;
  595.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  596. //    MyCaos.PPCStart        =    NULL;
  597. //    MyCaos.PPCSize        =    0;
  598.     MyCaos.d1        =(ULONG) port;
  599.     MyCaos.d2        =(ULONG) action;
  600.     MyCaos.caos_Un.Offset    =    (-240);
  601.     MyCaos.a6        =(ULONG) DOSBase;    
  602.     return((LONG)PPCCallOS(&MyCaos));
  603. }
  604.  
  605. #define    DoPkt1(port, action, arg1)    _DoPkt1(DOS_BASE_NAME, port, action, arg1)
  606.  
  607. static __inline LONG
  608. _DoPkt1(void *DOSBase, struct MsgPort *port, long action, long arg1)
  609. {
  610. struct Caos    MyCaos;
  611.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  612. //    MyCaos.M68kStart    =    NULL;
  613. //    MyCaos.M68kSize        =    0;
  614.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  615. //    MyCaos.PPCStart        =    NULL;
  616. //    MyCaos.PPCSize        =    0;
  617.     MyCaos.d1        =(ULONG) port;
  618.     MyCaos.d2        =(ULONG) action;
  619.     MyCaos.d3        =(ULONG) arg1;
  620.     MyCaos.caos_Un.Offset    =    (-240);
  621.     MyCaos.a6        =(ULONG) DOSBase;    
  622.     return((LONG)PPCCallOS(&MyCaos));
  623. }
  624.  
  625. #define    DoPkt2(port, action, arg1, arg2)    _DoPkt2(DOS_BASE_NAME, port, action, arg1, arg2)
  626.  
  627. static __inline LONG
  628. _DoPkt2(void *DOSBase, struct MsgPort *port, long action, long arg1, long arg2)
  629. {
  630. struct Caos    MyCaos;
  631.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  632. //    MyCaos.M68kStart    =    NULL;
  633. //    MyCaos.M68kSize        =    0;
  634.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  635. //    MyCaos.PPCStart        =    NULL;
  636. //    MyCaos.PPCSize        =    0;
  637.     MyCaos.d1        =(ULONG) port;
  638.     MyCaos.d2        =(ULONG) action;
  639.     MyCaos.d3        =(ULONG) arg1;
  640.     MyCaos.d4        =(ULONG) arg2;
  641.     MyCaos.caos_Un.Offset    =    (-240);
  642.     MyCaos.a6        =(ULONG) DOSBase;    
  643.     return((LONG)PPCCallOS(&MyCaos));
  644. }
  645.  
  646. #define    DoPkt3(port, action, arg1, arg2, arg3)    _DoPkt3(DOS_BASE_NAME, port, action, arg1, arg2, arg3)
  647.  
  648. static __inline LONG
  649. _DoPkt3(void *DOSBase, struct MsgPort *port, long action, long arg1, long arg2, long arg3)
  650. {
  651. struct Caos    MyCaos;
  652.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  653. //    MyCaos.M68kStart    =    NULL;
  654. //    MyCaos.M68kSize        =    0;
  655.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  656. //    MyCaos.PPCStart        =    NULL;
  657. //    MyCaos.PPCSize        =    0;
  658.     MyCaos.d1        =(ULONG) port;
  659.     MyCaos.d2        =(ULONG) action;
  660.     MyCaos.d3        =(ULONG) arg1;
  661.     MyCaos.d4        =(ULONG) arg2;
  662.     MyCaos.d5        =(ULONG) arg3;
  663.     MyCaos.caos_Un.Offset    =    (-240);
  664.     MyCaos.a6        =(ULONG) DOSBase;    
  665.     return((LONG)PPCCallOS(&MyCaos));
  666. }
  667.  
  668. #define    DoPkt4(port, action, arg1, arg2, arg3, arg4)    _DoPkt4(DOS_BASE_NAME, port, action, arg1, arg2, arg3, arg4)
  669.  
  670. static __inline LONG
  671. _DoPkt4(void *DOSBase, struct MsgPort *port, long action, long arg1, long arg2, long arg3, long arg4)
  672. {
  673. struct Caos    MyCaos;
  674.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  675. //    MyCaos.M68kStart    =    NULL;
  676. //    MyCaos.M68kSize        =    0;
  677.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  678. //    MyCaos.PPCStart        =    NULL;
  679. //    MyCaos.PPCSize        =    0;
  680.     MyCaos.d1        =(ULONG) port;
  681.     MyCaos.d2        =(ULONG) action;
  682.     MyCaos.d3        =(ULONG) arg1;
  683.     MyCaos.d4        =(ULONG) arg2;
  684.     MyCaos.d5        =(ULONG) arg3;
  685.     MyCaos.d6        =(ULONG) arg4;
  686.     MyCaos.caos_Un.Offset    =    (-240);
  687.     MyCaos.a6        =(ULONG) DOSBase;    
  688.     return((LONG)PPCCallOS(&MyCaos));
  689. }
  690.  
  691. #define    DupLock(lock)    _DupLock(DOS_BASE_NAME, lock)
  692.  
  693. static __inline BPTR
  694. _DupLock(void *DOSBase, BPTR lock)
  695. {
  696. struct Caos    MyCaos;
  697.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  698. //    MyCaos.M68kStart    =    NULL;
  699. //    MyCaos.M68kSize        =    0;
  700.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  701. //    MyCaos.PPCStart        =    NULL;
  702. //    MyCaos.PPCSize        =    0;
  703.     MyCaos.d1        =(ULONG) lock;
  704.     MyCaos.caos_Un.Offset    =    (-96);
  705.     MyCaos.a6        =(ULONG) DOSBase;    
  706.     return((BPTR)PPCCallOS(&MyCaos));
  707. }
  708.  
  709. #define    DupLockFromFH(fh)    _DupLockFromFH(DOS_BASE_NAME, fh)
  710.  
  711. static __inline BPTR
  712. _DupLockFromFH(void *DOSBase, BPTR fh)
  713. {
  714. struct Caos    MyCaos;
  715.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  716. //    MyCaos.M68kStart    =    NULL;
  717. //    MyCaos.M68kSize        =    0;
  718.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  719. //    MyCaos.PPCStart        =    NULL;
  720. //    MyCaos.PPCSize        =    0;
  721.     MyCaos.d1        =(ULONG) fh;
  722.     MyCaos.caos_Un.Offset    =    (-372);
  723.     MyCaos.a6        =(ULONG) DOSBase;    
  724.     return((BPTR)PPCCallOS(&MyCaos));
  725. }
  726.  
  727. #define    EndNotify(notify)    _EndNotify(DOS_BASE_NAME, notify)
  728.  
  729. static __inline void
  730. _EndNotify(void *DOSBase, struct NotifyRequest *notify)
  731. {
  732. struct Caos    MyCaos;
  733.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  734. //    MyCaos.M68kStart    =    NULL;
  735. //    MyCaos.M68kSize        =    0;
  736.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  737. //    MyCaos.PPCStart        =    NULL;
  738. //    MyCaos.PPCSize        =    0;
  739.     MyCaos.d1        =(ULONG) notify;
  740.     MyCaos.caos_Un.Offset    =    (-894);
  741.     MyCaos.a6        =(ULONG) DOSBase;    
  742.     PPCCallOS(&MyCaos);
  743. }
  744.  
  745. #define    ErrorReport(code, type, arg1, device)    _ErrorReport(DOS_BASE_NAME, code, type, arg1, device)
  746.  
  747. static __inline LONG
  748. _ErrorReport(void *DOSBase, long code, long type, unsigned long arg1, struct MsgPort *device)
  749. {
  750. struct Caos    MyCaos;
  751.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  752. //    MyCaos.M68kStart    =    NULL;
  753. //    MyCaos.M68kSize        =    0;
  754.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  755. //    MyCaos.PPCStart        =    NULL;
  756. //    MyCaos.PPCSize        =    0;
  757.     MyCaos.d1        =(ULONG) code;
  758.     MyCaos.d2        =(ULONG) type;
  759.     MyCaos.d3        =(ULONG) arg1;
  760.     MyCaos.d4        =(ULONG) device;
  761.     MyCaos.caos_Un.Offset    =    (-480);
  762.     MyCaos.a6        =(ULONG) DOSBase;    
  763.     return((LONG)PPCCallOS(&MyCaos));
  764. }
  765.  
  766. #define    ExAll(lock, buffer, size, data, control)    _ExAll(DOS_BASE_NAME, lock, buffer, size, data, control)
  767.  
  768. static __inline LONG
  769. _ExAll(void *DOSBase, BPTR lock, struct ExAllData *buffer, long size, long data, struct ExAllControl *control)
  770. {
  771. struct Caos    MyCaos;
  772.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  773. //    MyCaos.M68kStart    =    NULL;
  774. //    MyCaos.M68kSize        =    0;
  775.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  776. //    MyCaos.PPCStart        =    NULL;
  777. //    MyCaos.PPCSize        =    0;
  778.     MyCaos.d1        =(ULONG) lock;
  779.     MyCaos.d2        =(ULONG) buffer;
  780.     MyCaos.d3        =(ULONG) size;
  781.     MyCaos.d4        =(ULONG) data;
  782.     MyCaos.d5        =(ULONG) control;
  783.     MyCaos.caos_Un.Offset    =    (-432);
  784.     MyCaos.a6        =(ULONG) DOSBase;    
  785.     return((LONG)PPCCallOS(&MyCaos));
  786. }
  787.  
  788. #define    ExAllEnd(lock, buffer, size, data, control)    _ExAllEnd(DOS_BASE_NAME, lock, buffer, size, data, control)
  789.  
  790. static __inline void
  791. _ExAllEnd(void *DOSBase, BPTR lock, struct ExAllData *buffer, long size, long data, struct ExAllControl *control)
  792. {
  793. struct Caos    MyCaos;
  794.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  795. //    MyCaos.M68kStart    =    NULL;
  796. //    MyCaos.M68kSize        =    0;
  797.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  798. //    MyCaos.PPCStart        =    NULL;
  799. //    MyCaos.PPCSize        =    0;
  800.     MyCaos.d1        =(ULONG) lock;
  801.     MyCaos.d2        =(ULONG) buffer;
  802.     MyCaos.d3        =(ULONG) size;
  803.     MyCaos.d4        =(ULONG) data;
  804.     MyCaos.d5        =(ULONG) control;
  805.     MyCaos.caos_Un.Offset    =    (-990);
  806.     MyCaos.a6        =(ULONG) DOSBase;    
  807.     PPCCallOS(&MyCaos);
  808. }
  809.  
  810. #define    ExNext(lock, fileInfoBlock)    _ExNext(DOS_BASE_NAME, lock, fileInfoBlock)
  811.  
  812. static __inline LONG
  813. _ExNext(void *DOSBase, BPTR lock, struct FileInfoBlock *fileInfoBlock)
  814. {
  815. struct Caos    MyCaos;
  816.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  817. //    MyCaos.M68kStart    =    NULL;
  818. //    MyCaos.M68kSize        =    0;
  819.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  820. //    MyCaos.PPCStart        =    NULL;
  821. //    MyCaos.PPCSize        =    0;
  822.     MyCaos.d1        =(ULONG) lock;
  823.     MyCaos.d2        =(ULONG) fileInfoBlock;
  824.     MyCaos.caos_Un.Offset    =    (-108);
  825.     MyCaos.a6        =(ULONG) DOSBase;    
  826.     return((LONG)PPCCallOS(&MyCaos));
  827. }
  828.  
  829. #define    Examine(lock, fileInfoBlock)    _Examine(DOS_BASE_NAME, lock, fileInfoBlock)
  830.  
  831. static __inline LONG
  832. _Examine(void *DOSBase, BPTR lock, struct FileInfoBlock *fileInfoBlock)
  833. {
  834. struct Caos    MyCaos;
  835.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  836. //    MyCaos.M68kStart    =    NULL;
  837. //    MyCaos.M68kSize        =    0;
  838.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  839. //    MyCaos.PPCStart        =    NULL;
  840. //    MyCaos.PPCSize        =    0;
  841.     MyCaos.d1        =(ULONG) lock;
  842.     MyCaos.d2        =(ULONG) fileInfoBlock;
  843.     MyCaos.caos_Un.Offset    =    (-102);
  844.     MyCaos.a6        =(ULONG) DOSBase;    
  845.     return((LONG)PPCCallOS(&MyCaos));
  846. }
  847.  
  848. #define    ExamineFH(fh, fib)    _ExamineFH(DOS_BASE_NAME, fh, fib)
  849.  
  850. static __inline BOOL
  851. _ExamineFH(void *DOSBase, BPTR fh, struct FileInfoBlock *fib)
  852. {
  853. struct Caos    MyCaos;
  854.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  855. //    MyCaos.M68kStart    =    NULL;
  856. //    MyCaos.M68kSize        =    0;
  857.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  858. //    MyCaos.PPCStart        =    NULL;
  859. //    MyCaos.PPCSize        =    0;
  860.     MyCaos.d1        =(ULONG) fh;
  861.     MyCaos.d2        =(ULONG) fib;
  862.     MyCaos.caos_Un.Offset    =    (-390);
  863.     MyCaos.a6        =(ULONG) DOSBase;    
  864.     return((BOOL)PPCCallOS(&MyCaos));
  865. }
  866.  
  867. #define    Execute(string, file, file2)    _Execute(DOS_BASE_NAME, string, file, file2)
  868.  
  869. static __inline LONG
  870. _Execute(void *DOSBase, STRPTR string, BPTR file, BPTR file2)
  871. {
  872. struct Caos    MyCaos;
  873.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  874. //    MyCaos.M68kStart    =    NULL;
  875. //    MyCaos.M68kSize        =    0;
  876.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  877. //    MyCaos.PPCStart        =    NULL;
  878. //    MyCaos.PPCSize        =    0;
  879.     MyCaos.d1        =(ULONG) string;
  880.     MyCaos.d2        =(ULONG) file;
  881.     MyCaos.d3        =(ULONG) file2;
  882.     MyCaos.caos_Un.Offset    =    (-222);
  883.     MyCaos.a6        =(ULONG) DOSBase;    
  884.     return((LONG)PPCCallOS(&MyCaos));
  885. }
  886.  
  887. #define    Exit(returnCode)    _Exit(DOS_BASE_NAME, returnCode)
  888.  
  889. static __inline void
  890. _Exit(void *DOSBase, long returnCode)
  891. {
  892. struct Caos    MyCaos;
  893.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  894. //    MyCaos.M68kStart    =    NULL;
  895. //    MyCaos.M68kSize        =    0;
  896.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  897. //    MyCaos.PPCStart        =    NULL;
  898. //    MyCaos.PPCSize        =    0;
  899.     MyCaos.d1        =(ULONG) returnCode;
  900.     MyCaos.caos_Un.Offset    =    (-144);
  901.     MyCaos.a6        =(ULONG) DOSBase;    
  902.     PPCCallOS(&MyCaos);
  903. }
  904.  
  905. #define    FGetC(fh)    _FGetC(DOS_BASE_NAME, fh)
  906.  
  907. static __inline LONG
  908. _FGetC(void *DOSBase, BPTR fh)
  909. {
  910. struct Caos    MyCaos;
  911.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  912. //    MyCaos.M68kStart    =    NULL;
  913. //    MyCaos.M68kSize        =    0;
  914.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  915. //    MyCaos.PPCStart        =    NULL;
  916. //    MyCaos.PPCSize        =    0;
  917.     MyCaos.d1        =(ULONG) fh;
  918.     MyCaos.caos_Un.Offset    =    (-306);
  919.     MyCaos.a6        =(ULONG) DOSBase;    
  920.     return((LONG)PPCCallOS(&MyCaos));
  921. }
  922.  
  923. #define    FGets(fh, buf, buflen)    _FGets(DOS_BASE_NAME, fh, buf, buflen)
  924.  
  925. static __inline STRPTR
  926. _FGets(void *DOSBase, BPTR fh, STRPTR buf, unsigned long buflen)
  927. {
  928. struct Caos    MyCaos;
  929.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  930. //    MyCaos.M68kStart    =    NULL;
  931. //    MyCaos.M68kSize        =    0;
  932.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  933. //    MyCaos.PPCStart        =    NULL;
  934. //    MyCaos.PPCSize        =    0;
  935.     MyCaos.d1        =(ULONG) fh;
  936.     MyCaos.d2        =(ULONG) buf;
  937.     MyCaos.d3        =(ULONG) buflen;
  938.     MyCaos.caos_Un.Offset    =    (-336);
  939.     MyCaos.a6        =(ULONG) DOSBase;    
  940.     return((STRPTR)PPCCallOS(&MyCaos));
  941. }
  942.  
  943. #define    FPutC(fh, ch)    _FPutC(DOS_BASE_NAME, fh, ch)
  944.  
  945. static __inline LONG
  946. _FPutC(void *DOSBase, BPTR fh, long ch)
  947. {
  948. struct Caos    MyCaos;
  949.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  950. //    MyCaos.M68kStart    =    NULL;
  951. //    MyCaos.M68kSize        =    0;
  952.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  953. //    MyCaos.PPCStart        =    NULL;
  954. //    MyCaos.PPCSize        =    0;
  955.     MyCaos.d1        =(ULONG) fh;
  956.     MyCaos.d2        =(ULONG) ch;
  957.     MyCaos.caos_Un.Offset    =    (-312);
  958.     MyCaos.a6        =(ULONG) DOSBase;    
  959.     return((LONG)PPCCallOS(&MyCaos));
  960. }
  961.  
  962. #define    FPuts(fh, str)    _FPuts(DOS_BASE_NAME, fh, str)
  963.  
  964. static __inline LONG
  965. _FPuts(void *DOSBase, BPTR fh, STRPTR str)
  966. {
  967. struct Caos    MyCaos;
  968.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  969. //    MyCaos.M68kStart    =    NULL;
  970. //    MyCaos.M68kSize        =    0;
  971.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  972. //    MyCaos.PPCStart        =    NULL;
  973. //    MyCaos.PPCSize        =    0;
  974.     MyCaos.d1        =(ULONG) fh;
  975.     MyCaos.d2        =(ULONG) str;
  976.     MyCaos.caos_Un.Offset    =    (-342);
  977.     MyCaos.a6        =(ULONG) DOSBase;    
  978.     return((LONG)PPCCallOS(&MyCaos));
  979. }
  980.  
  981. #define    FRead(fh, block, blocklen, number)    _FRead(DOS_BASE_NAME, fh, block, blocklen, number)
  982.  
  983. static __inline LONG
  984. _FRead(void *DOSBase, BPTR fh, APTR block, unsigned long blocklen, unsigned long number)
  985. {
  986. struct Caos    MyCaos;
  987.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  988. //    MyCaos.M68kStart    =    NULL;
  989. //    MyCaos.M68kSize        =    0;
  990.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  991. //    MyCaos.PPCStart        =    NULL;
  992. //    MyCaos.PPCSize        =    0;
  993.     MyCaos.d1        =(ULONG) fh;
  994.     MyCaos.d2        =(ULONG) block;
  995.     MyCaos.d3        =(ULONG) blocklen;
  996.     MyCaos.d4        =(ULONG) number;
  997.     MyCaos.caos_Un.Offset    =    (-324);
  998.     MyCaos.a6        =(ULONG) DOSBase;    
  999.     return((LONG)PPCCallOS(&MyCaos));
  1000. }
  1001.  
  1002. #define    FWrite(fh, block, blocklen, number)    _FWrite(DOS_BASE_NAME, fh, block, blocklen, number)
  1003.  
  1004. static __inline LONG
  1005. _FWrite(void *DOSBase, BPTR fh, APTR block, unsigned long blocklen, unsigned long number)
  1006. {
  1007. struct Caos    MyCaos;
  1008.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1009. //    MyCaos.M68kStart    =    NULL;
  1010. //    MyCaos.M68kSize        =    0;
  1011.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1012. //    MyCaos.PPCStart        =    NULL;
  1013. //    MyCaos.PPCSize        =    0;
  1014.     MyCaos.d1        =(ULONG) fh;
  1015.     MyCaos.d2        =(ULONG) block;
  1016.     MyCaos.d3        =(ULONG) blocklen;
  1017.     MyCaos.d4        =(ULONG) number;
  1018.     MyCaos.caos_Un.Offset    =    (-330);
  1019.     MyCaos.a6        =(ULONG) DOSBase;    
  1020.     return((LONG)PPCCallOS(&MyCaos));
  1021. }
  1022.  
  1023. #define    Fault(code, header, buffer, len)    _Fault(DOS_BASE_NAME, code, header, buffer, len)
  1024.  
  1025. static __inline BOOL
  1026. _Fault(void *DOSBase, long code, STRPTR header, STRPTR buffer, long len)
  1027. {
  1028. struct Caos    MyCaos;
  1029.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1030. //    MyCaos.M68kStart    =    NULL;
  1031. //    MyCaos.M68kSize        =    0;
  1032.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1033. //    MyCaos.PPCStart        =    NULL;
  1034. //    MyCaos.PPCSize        =    0;
  1035.     MyCaos.d1        =(ULONG) code;
  1036.     MyCaos.d2        =(ULONG) header;
  1037.     MyCaos.d3        =(ULONG) buffer;
  1038.     MyCaos.d4        =(ULONG) len;
  1039.     MyCaos.caos_Un.Offset    =    (-468);
  1040.     MyCaos.a6        =(ULONG) DOSBase;    
  1041.     return((BOOL)PPCCallOS(&MyCaos));
  1042. }
  1043.  
  1044. #define    FilePart(path)    _FilePart(DOS_BASE_NAME, path)
  1045.  
  1046. static __inline STRPTR
  1047. _FilePart(void *DOSBase, STRPTR path)
  1048. {
  1049. struct Caos    MyCaos;
  1050.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1051. //    MyCaos.M68kStart    =    NULL;
  1052. //    MyCaos.M68kSize        =    0;
  1053.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1054. //    MyCaos.PPCStart        =    NULL;
  1055. //    MyCaos.PPCSize        =    0;
  1056.     MyCaos.d1        =(ULONG) path;
  1057.     MyCaos.caos_Un.Offset    =    (-870);
  1058.     MyCaos.a6        =(ULONG) DOSBase;    
  1059.     return((STRPTR)PPCCallOS(&MyCaos));
  1060. }
  1061.  
  1062. #define    FindArg(keyword, arg_template)    _FindArg(DOS_BASE_NAME, keyword, arg_template)
  1063.  
  1064. static __inline LONG
  1065. _FindArg(void *DOSBase, STRPTR keyword, STRPTR arg_template)
  1066. {
  1067. struct Caos    MyCaos;
  1068.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1069. //    MyCaos.M68kStart    =    NULL;
  1070. //    MyCaos.M68kSize        =    0;
  1071.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1072. //    MyCaos.PPCStart        =    NULL;
  1073. //    MyCaos.PPCSize        =    0;
  1074.     MyCaos.d1        =(ULONG) keyword;
  1075.     MyCaos.d2        =(ULONG) arg_template;
  1076.     MyCaos.caos_Un.Offset    =    (-804);
  1077.     MyCaos.a6        =(ULONG) DOSBase;    
  1078.     return((LONG)PPCCallOS(&MyCaos));
  1079. }
  1080.  
  1081. #define    FindCliProc(num)    _FindCliProc(DOS_BASE_NAME, num)
  1082.  
  1083. static __inline struct Process *
  1084. _FindCliProc(void *DOSBase, unsigned long num)
  1085. {
  1086. struct Caos    MyCaos;
  1087.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1088. //    MyCaos.M68kStart    =    NULL;
  1089. //    MyCaos.M68kSize        =    0;
  1090.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1091. //    MyCaos.PPCStart        =    NULL;
  1092. //    MyCaos.PPCSize        =    0;
  1093.     MyCaos.d1        =(ULONG) num;
  1094.     MyCaos.caos_Un.Offset    =    (-546);
  1095.     MyCaos.a6        =(ULONG) DOSBase;    
  1096.     return((struct Process *)PPCCallOS(&MyCaos));
  1097. }
  1098.  
  1099. #define    FindDosEntry(dlist, name, flags)    _FindDosEntry(DOS_BASE_NAME, dlist, name, flags)
  1100.  
  1101. static __inline struct DosList *
  1102. _FindDosEntry(void *DOSBase, struct DosList *dlist, STRPTR name, unsigned long flags)
  1103. {
  1104. struct Caos    MyCaos;
  1105.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1106. //    MyCaos.M68kStart    =    NULL;
  1107. //    MyCaos.M68kSize        =    0;
  1108.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1109. //    MyCaos.PPCStart        =    NULL;
  1110. //    MyCaos.PPCSize        =    0;
  1111.     MyCaos.d1        =(ULONG) dlist;
  1112.     MyCaos.d2        =(ULONG) name;
  1113.     MyCaos.d3        =(ULONG) flags;
  1114.     MyCaos.caos_Un.Offset    =    (-684);
  1115.     MyCaos.a6        =(ULONG) DOSBase;    
  1116.     return((struct DosList *)PPCCallOS(&MyCaos));
  1117. }
  1118.  
  1119. #define    FindSegment(name, seg, system)    _FindSegment(DOS_BASE_NAME, name, seg, system)
  1120.  
  1121. static __inline struct Segment *
  1122. _FindSegment(void *DOSBase, STRPTR name, struct Segment *seg, long system)
  1123. {
  1124. struct Caos    MyCaos;
  1125.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1126. //    MyCaos.M68kStart    =    NULL;
  1127. //    MyCaos.M68kSize        =    0;
  1128.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1129. //    MyCaos.PPCStart        =    NULL;
  1130. //    MyCaos.PPCSize        =    0;
  1131.     MyCaos.d1        =(ULONG) name;
  1132.     MyCaos.d2        =(ULONG) seg;
  1133.     MyCaos.d3        =(ULONG) system;
  1134.     MyCaos.caos_Un.Offset    =    (-780);
  1135.     MyCaos.a6        =(ULONG) DOSBase;    
  1136.     return((struct Segment *)PPCCallOS(&MyCaos));
  1137. }
  1138.  
  1139. #define    FindVar(name, type)    _FindVar(DOS_BASE_NAME, name, type)
  1140.  
  1141. static __inline struct LocalVar *
  1142. _FindVar(void *DOSBase, STRPTR name, unsigned long type)
  1143. {
  1144. struct Caos    MyCaos;
  1145.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1146. //    MyCaos.M68kStart    =    NULL;
  1147. //    MyCaos.M68kSize        =    0;
  1148.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1149. //    MyCaos.PPCStart        =    NULL;
  1150. //    MyCaos.PPCSize        =    0;
  1151.     MyCaos.d1        =(ULONG) name;
  1152.     MyCaos.d2        =(ULONG) type;
  1153.     MyCaos.caos_Un.Offset    =    (-918);
  1154.     MyCaos.a6        =(ULONG) DOSBase;    
  1155.     return((struct LocalVar *)PPCCallOS(&MyCaos));
  1156. }
  1157.  
  1158. #define    Flush(fh)    _Flush(DOS_BASE_NAME, fh)
  1159.  
  1160. static __inline LONG
  1161. _Flush(void *DOSBase, BPTR fh)
  1162. {
  1163. struct Caos    MyCaos;
  1164.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1165. //    MyCaos.M68kStart    =    NULL;
  1166. //    MyCaos.M68kSize        =    0;
  1167.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1168. //    MyCaos.PPCStart        =    NULL;
  1169. //    MyCaos.PPCSize        =    0;
  1170.     MyCaos.d1        =(ULONG) fh;
  1171.     MyCaos.caos_Un.Offset    =    (-360);
  1172.     MyCaos.a6        =(ULONG) DOSBase;    
  1173.     return((LONG)PPCCallOS(&MyCaos));
  1174. }
  1175.  
  1176. #define    Format(filesystem, volumename, dostype)    _Format(DOS_BASE_NAME, filesystem, volumename, dostype)
  1177.  
  1178. static __inline BOOL
  1179. _Format(void *DOSBase, STRPTR filesystem, STRPTR volumename, unsigned long dostype)
  1180. {
  1181. struct Caos    MyCaos;
  1182.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1183. //    MyCaos.M68kStart    =    NULL;
  1184. //    MyCaos.M68kSize        =    0;
  1185.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1186. //    MyCaos.PPCStart        =    NULL;
  1187. //    MyCaos.PPCSize        =    0;
  1188.     MyCaos.d1        =(ULONG) filesystem;
  1189.     MyCaos.d2        =(ULONG) volumename;
  1190.     MyCaos.d3        =(ULONG) dostype;
  1191.     MyCaos.caos_Un.Offset    =    (-714);
  1192.     MyCaos.a6        =(ULONG) DOSBase;    
  1193.     return((BOOL)PPCCallOS(&MyCaos));
  1194. }
  1195.  
  1196. #define    FreeArgs(args)    _FreeArgs(DOS_BASE_NAME, args)
  1197.  
  1198. static __inline void
  1199. _FreeArgs(void *DOSBase, struct RDArgs *args)
  1200. {
  1201. struct Caos    MyCaos;
  1202.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1203. //    MyCaos.M68kStart    =    NULL;
  1204. //    MyCaos.M68kSize        =    0;
  1205.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1206. //    MyCaos.PPCStart        =    NULL;
  1207. //    MyCaos.PPCSize        =    0;
  1208.     MyCaos.d1        =(ULONG) args;
  1209.     MyCaos.caos_Un.Offset    =    (-858);
  1210.     MyCaos.a6        =(ULONG) DOSBase;    
  1211.     PPCCallOS(&MyCaos);
  1212. }
  1213.  
  1214. #define    FreeDeviceProc(dp)    _FreeDeviceProc(DOS_BASE_NAME, dp)
  1215.  
  1216. static __inline void
  1217. _FreeDeviceProc(void *DOSBase, struct DevProc *dp)
  1218. {
  1219. struct Caos    MyCaos;
  1220.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1221. //    MyCaos.M68kStart    =    NULL;
  1222. //    MyCaos.M68kSize        =    0;
  1223.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1224. //    MyCaos.PPCStart        =    NULL;
  1225. //    MyCaos.PPCSize        =    0;
  1226.     MyCaos.d1        =(ULONG) dp;
  1227.     MyCaos.caos_Un.Offset    =    (-648);
  1228.     MyCaos.a6        =(ULONG) DOSBase;    
  1229.     PPCCallOS(&MyCaos);
  1230. }
  1231.  
  1232. #define    FreeDosEntry(dlist)    _FreeDosEntry(DOS_BASE_NAME, dlist)
  1233.  
  1234. static __inline void
  1235. _FreeDosEntry(void *DOSBase, struct DosList *dlist)
  1236. {
  1237. struct Caos    MyCaos;
  1238.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1239. //    MyCaos.M68kStart    =    NULL;
  1240. //    MyCaos.M68kSize        =    0;
  1241.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1242. //    MyCaos.PPCStart        =    NULL;
  1243. //    MyCaos.PPCSize        =    0;
  1244.     MyCaos.d1        =(ULONG) dlist;
  1245.     MyCaos.caos_Un.Offset    =    (-702);
  1246.     MyCaos.a6        =(ULONG) DOSBase;    
  1247.     PPCCallOS(&MyCaos);
  1248. }
  1249.  
  1250. #define    FreeDosObject(type, ptr)    _FreeDosObject(DOS_BASE_NAME, type, ptr)
  1251.  
  1252. static __inline void
  1253. _FreeDosObject(void *DOSBase, unsigned long type, APTR ptr)
  1254. {
  1255. struct Caos    MyCaos;
  1256.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1257. //    MyCaos.M68kStart    =    NULL;
  1258. //    MyCaos.M68kSize        =    0;
  1259.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1260. //    MyCaos.PPCStart        =    NULL;
  1261. //    MyCaos.PPCSize        =    0;
  1262.     MyCaos.d1        =(ULONG) type;
  1263.     MyCaos.d2        =(ULONG) ptr;
  1264.     MyCaos.caos_Un.Offset    =    (-234);
  1265.     MyCaos.a6        =(ULONG) DOSBase;    
  1266.     PPCCallOS(&MyCaos);
  1267. }
  1268.  
  1269. #define    GetArgStr()    _GetArgStr(DOS_BASE_NAME)
  1270.  
  1271. static __inline STRPTR
  1272. _GetArgStr(void *DOSBase)
  1273. {
  1274. struct Caos    MyCaos;
  1275.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1276. //    MyCaos.M68kStart    =    NULL;
  1277. //    MyCaos.M68kSize        =    0;
  1278.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1279. //    MyCaos.PPCStart        =    NULL;
  1280. //    MyCaos.PPCSize        =    0;
  1281.     MyCaos.caos_Un.Offset    =    (-534);
  1282.     MyCaos.a6        =(ULONG) DOSBase;    
  1283.     return((STRPTR)PPCCallOS(&MyCaos));
  1284. }
  1285.  
  1286. #define    GetConsoleTask()    _GetConsoleTask(DOS_BASE_NAME)
  1287.  
  1288. static __inline struct MsgPort *
  1289. _GetConsoleTask(void *DOSBase)
  1290. {
  1291. struct Caos    MyCaos;
  1292.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1293. //    MyCaos.M68kStart    =    NULL;
  1294. //    MyCaos.M68kSize        =    0;
  1295.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1296. //    MyCaos.PPCStart        =    NULL;
  1297. //    MyCaos.PPCSize        =    0;
  1298.     MyCaos.caos_Un.Offset    =    (-510);
  1299.     MyCaos.a6        =(ULONG) DOSBase;    
  1300.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  1301. }
  1302.  
  1303. #define    GetCurrentDirName(buf, len)    _GetCurrentDirName(DOS_BASE_NAME, buf, len)
  1304.  
  1305. static __inline BOOL
  1306. _GetCurrentDirName(void *DOSBase, STRPTR buf, long len)
  1307. {
  1308. struct Caos    MyCaos;
  1309.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1310. //    MyCaos.M68kStart    =    NULL;
  1311. //    MyCaos.M68kSize        =    0;
  1312.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1313. //    MyCaos.PPCStart        =    NULL;
  1314. //    MyCaos.PPCSize        =    0;
  1315.     MyCaos.d1        =(ULONG) buf;
  1316.     MyCaos.d2        =(ULONG) len;
  1317.     MyCaos.caos_Un.Offset    =    (-564);
  1318.     MyCaos.a6        =(ULONG) DOSBase;    
  1319.     return((BOOL)PPCCallOS(&MyCaos));
  1320. }
  1321.  
  1322. #define    GetDeviceProc(name, dp)    _GetDeviceProc(DOS_BASE_NAME, name, dp)
  1323.  
  1324. static __inline struct DevProc *
  1325. _GetDeviceProc(void *DOSBase, STRPTR name, struct DevProc *dp)
  1326. {
  1327. struct Caos    MyCaos;
  1328.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1329. //    MyCaos.M68kStart    =    NULL;
  1330. //    MyCaos.M68kSize        =    0;
  1331.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1332. //    MyCaos.PPCStart        =    NULL;
  1333. //    MyCaos.PPCSize        =    0;
  1334.     MyCaos.d1        =(ULONG) name;
  1335.     MyCaos.d2        =(ULONG) dp;
  1336.     MyCaos.caos_Un.Offset    =    (-642);
  1337.     MyCaos.a6        =(ULONG) DOSBase;    
  1338.     return((struct DevProc *)PPCCallOS(&MyCaos));
  1339. }
  1340.  
  1341. #define    GetFileSysTask()    _GetFileSysTask(DOS_BASE_NAME)
  1342.  
  1343. static __inline struct MsgPort *
  1344. _GetFileSysTask(void *DOSBase)
  1345. {
  1346. struct Caos    MyCaos;
  1347.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1348. //    MyCaos.M68kStart    =    NULL;
  1349. //    MyCaos.M68kSize        =    0;
  1350.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1351. //    MyCaos.PPCStart        =    NULL;
  1352. //    MyCaos.PPCSize        =    0;
  1353.     MyCaos.caos_Un.Offset    =    (-522);
  1354.     MyCaos.a6        =(ULONG) DOSBase;    
  1355.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  1356. }
  1357.  
  1358. #define    GetProgramDir()    _GetProgramDir(DOS_BASE_NAME)
  1359.  
  1360. static __inline BPTR
  1361. _GetProgramDir(void *DOSBase)
  1362. {
  1363. struct Caos    MyCaos;
  1364.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1365. //    MyCaos.M68kStart    =    NULL;
  1366. //    MyCaos.M68kSize        =    0;
  1367.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1368. //    MyCaos.PPCStart        =    NULL;
  1369. //    MyCaos.PPCSize        =    0;
  1370.     MyCaos.caos_Un.Offset    =    (-600);
  1371.     MyCaos.a6        =(ULONG) DOSBase;    
  1372.     return((BPTR)PPCCallOS(&MyCaos));
  1373. }
  1374.  
  1375. #define    GetProgramName(buf, len)    _GetProgramName(DOS_BASE_NAME, buf, len)
  1376.  
  1377. static __inline BOOL
  1378. _GetProgramName(void *DOSBase, STRPTR buf, long len)
  1379. {
  1380. struct Caos    MyCaos;
  1381.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1382. //    MyCaos.M68kStart    =    NULL;
  1383. //    MyCaos.M68kSize        =    0;
  1384.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1385. //    MyCaos.PPCStart        =    NULL;
  1386. //    MyCaos.PPCSize        =    0;
  1387.     MyCaos.d1        =(ULONG) buf;
  1388.     MyCaos.d2        =(ULONG) len;
  1389.     MyCaos.caos_Un.Offset    =    (-576);
  1390.     MyCaos.a6        =(ULONG) DOSBase;    
  1391.     return((BOOL)PPCCallOS(&MyCaos));
  1392. }
  1393.  
  1394. #define    GetPrompt(buf, len)    _GetPrompt(DOS_BASE_NAME, buf, len)
  1395.  
  1396. static __inline BOOL
  1397. _GetPrompt(void *DOSBase, STRPTR buf, long len)
  1398. {
  1399. struct Caos    MyCaos;
  1400.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1401. //    MyCaos.M68kStart    =    NULL;
  1402. //    MyCaos.M68kSize        =    0;
  1403.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1404. //    MyCaos.PPCStart        =    NULL;
  1405. //    MyCaos.PPCSize        =    0;
  1406.     MyCaos.d1        =(ULONG) buf;
  1407.     MyCaos.d2        =(ULONG) len;
  1408.     MyCaos.caos_Un.Offset    =    (-588);
  1409.     MyCaos.a6        =(ULONG) DOSBase;    
  1410.     return((BOOL)PPCCallOS(&MyCaos));
  1411. }
  1412.  
  1413. #define    GetVar(name, buffer, size, flags)    _GetVar(DOS_BASE_NAME, name, buffer, size, flags)
  1414.  
  1415. static __inline LONG
  1416. _GetVar(void *DOSBase, STRPTR name, STRPTR buffer, long size, long flags)
  1417. {
  1418. struct Caos    MyCaos;
  1419.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1420. //    MyCaos.M68kStart    =    NULL;
  1421. //    MyCaos.M68kSize        =    0;
  1422.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1423. //    MyCaos.PPCStart        =    NULL;
  1424. //    MyCaos.PPCSize        =    0;
  1425.     MyCaos.d1        =(ULONG) name;
  1426.     MyCaos.d2        =(ULONG) buffer;
  1427.     MyCaos.d3        =(ULONG) size;
  1428.     MyCaos.d4        =(ULONG) flags;
  1429.     MyCaos.caos_Un.Offset    =    (-906);
  1430.     MyCaos.a6        =(ULONG) DOSBase;    
  1431.     return((LONG)PPCCallOS(&MyCaos));
  1432. }
  1433.  
  1434. #define    Info(lock, parameterBlock)    _Info(DOS_BASE_NAME, lock, parameterBlock)
  1435.  
  1436. static __inline LONG
  1437. _Info(void *DOSBase, BPTR lock, struct InfoData *parameterBlock)
  1438. {
  1439. struct Caos    MyCaos;
  1440.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1441. //    MyCaos.M68kStart    =    NULL;
  1442. //    MyCaos.M68kSize        =    0;
  1443.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1444. //    MyCaos.PPCStart        =    NULL;
  1445. //    MyCaos.PPCSize        =    0;
  1446.     MyCaos.d1        =(ULONG) lock;
  1447.     MyCaos.d2        =(ULONG) parameterBlock;
  1448.     MyCaos.caos_Un.Offset    =    (-114);
  1449.     MyCaos.a6        =(ULONG) DOSBase;    
  1450.     return((LONG)PPCCallOS(&MyCaos));
  1451. }
  1452.  
  1453. #define    Inhibit(name, onoff)    _Inhibit(DOS_BASE_NAME, name, onoff)
  1454.  
  1455. static __inline LONG
  1456. _Inhibit(void *DOSBase, STRPTR name, long onoff)
  1457. {
  1458. struct Caos    MyCaos;
  1459.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1460. //    MyCaos.M68kStart    =    NULL;
  1461. //    MyCaos.M68kSize        =    0;
  1462.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1463. //    MyCaos.PPCStart        =    NULL;
  1464. //    MyCaos.PPCSize        =    0;
  1465.     MyCaos.d1        =(ULONG) name;
  1466.     MyCaos.d2        =(ULONG) onoff;
  1467.     MyCaos.caos_Un.Offset    =    (-726);
  1468.     MyCaos.a6        =(ULONG) DOSBase;    
  1469.     return((LONG)PPCCallOS(&MyCaos));
  1470. }
  1471.  
  1472. #define    Input()    _Input(DOS_BASE_NAME)
  1473.  
  1474. static __inline BPTR
  1475. _Input(void *DOSBase)
  1476. {
  1477. struct Caos    MyCaos;
  1478.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1479. //    MyCaos.M68kStart    =    NULL;
  1480. //    MyCaos.M68kSize        =    0;
  1481.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1482. //    MyCaos.PPCStart        =    NULL;
  1483. //    MyCaos.PPCSize        =    0;
  1484.     MyCaos.caos_Un.Offset    =    (-54);
  1485.     MyCaos.a6        =(ULONG) DOSBase;    
  1486.     return((BPTR)PPCCallOS(&MyCaos));
  1487. }
  1488.  
  1489. #define    InternalLoadSeg(fh, table, funcarray, stack)    _InternalLoadSeg(DOS_BASE_NAME, fh, table, funcarray, stack)
  1490.  
  1491. static __inline BPTR
  1492. _InternalLoadSeg(void *DOSBase, BPTR fh, BPTR table, LONG *funcarray, LONG *stack)
  1493. {
  1494. struct Caos    MyCaos;
  1495.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1496. //    MyCaos.M68kStart    =    NULL;
  1497. //    MyCaos.M68kSize        =    0;
  1498.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1499. //    MyCaos.PPCStart        =    NULL;
  1500. //    MyCaos.PPCSize        =    0;
  1501.     MyCaos.d0        =(ULONG) fh;
  1502.     MyCaos.a0        =(ULONG) table;
  1503.     MyCaos.a1        =(ULONG) funcarray;
  1504.     MyCaos.a2        =(ULONG) stack;
  1505.     MyCaos.caos_Un.Offset    =    (-756);
  1506.     MyCaos.a6        =(ULONG) DOSBase;    
  1507.     return((BPTR)PPCCallOS(&MyCaos));
  1508. }
  1509.  
  1510. #define    InternalUnLoadSeg(seglist, freefunc)    _InternalUnLoadSeg(DOS_BASE_NAME, seglist, freefunc)
  1511.  
  1512. static __inline BOOL
  1513. _InternalUnLoadSeg(void *DOSBase, BPTR seglist, void (*freefunc)())
  1514. {
  1515. struct Caos    MyCaos;
  1516.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1517. //    MyCaos.M68kStart    =    NULL;
  1518. //    MyCaos.M68kSize        =    0;
  1519.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1520. //    MyCaos.PPCStart        =    NULL;
  1521. //    MyCaos.PPCSize        =    0;
  1522.     MyCaos.d1        =(ULONG) seglist;
  1523.     MyCaos.a1        =(ULONG) freefunc;
  1524.     MyCaos.caos_Un.Offset    =    (-762);
  1525.     MyCaos.a6        =(ULONG) DOSBase;    
  1526.     return((BOOL)PPCCallOS(&MyCaos));
  1527. }
  1528.  
  1529. #define    IoErr()    _IoErr(DOS_BASE_NAME)
  1530.  
  1531. static __inline LONG
  1532. _IoErr(void *DOSBase)
  1533. {
  1534. struct Caos    MyCaos;
  1535.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1536. //    MyCaos.M68kStart    =    NULL;
  1537. //    MyCaos.M68kSize        =    0;
  1538.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1539. //    MyCaos.PPCStart        =    NULL;
  1540. //    MyCaos.PPCSize        =    0;
  1541.     MyCaos.caos_Un.Offset    =    (-132);
  1542.     MyCaos.a6        =(ULONG) DOSBase;    
  1543.     return((LONG)PPCCallOS(&MyCaos));
  1544. }
  1545.  
  1546. #define    IsFileSystem(name)    _IsFileSystem(DOS_BASE_NAME, name)
  1547.  
  1548. static __inline BOOL
  1549. _IsFileSystem(void *DOSBase, STRPTR name)
  1550. {
  1551. struct Caos    MyCaos;
  1552.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1553. //    MyCaos.M68kStart    =    NULL;
  1554. //    MyCaos.M68kSize        =    0;
  1555.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1556. //    MyCaos.PPCStart        =    NULL;
  1557. //    MyCaos.PPCSize        =    0;
  1558.     MyCaos.d1        =(ULONG) name;
  1559.     MyCaos.caos_Un.Offset    =    (-708);
  1560.     MyCaos.a6        =(ULONG) DOSBase;    
  1561.     return((BOOL)PPCCallOS(&MyCaos));
  1562. }
  1563.  
  1564. #define    IsInteractive(file)    _IsInteractive(DOS_BASE_NAME, file)
  1565.  
  1566. static __inline LONG
  1567. _IsInteractive(void *DOSBase, BPTR file)
  1568. {
  1569. struct Caos    MyCaos;
  1570.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1571. //    MyCaos.M68kStart    =    NULL;
  1572. //    MyCaos.M68kSize        =    0;
  1573.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1574. //    MyCaos.PPCStart        =    NULL;
  1575. //    MyCaos.PPCSize        =    0;
  1576.     MyCaos.d1        =(ULONG) file;
  1577.     MyCaos.caos_Un.Offset    =    (-216);
  1578.     MyCaos.a6        =(ULONG) DOSBase;    
  1579.     return((LONG)PPCCallOS(&MyCaos));
  1580. }
  1581.  
  1582. #define    LoadSeg(name)    _LoadSeg(DOS_BASE_NAME, name)
  1583.  
  1584. static __inline BPTR
  1585. _LoadSeg(void *DOSBase, STRPTR name)
  1586. {
  1587. struct Caos    MyCaos;
  1588.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1589. //    MyCaos.M68kStart    =    NULL;
  1590. //    MyCaos.M68kSize        =    0;
  1591.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1592. //    MyCaos.PPCStart        =    NULL;
  1593. //    MyCaos.PPCSize        =    0;
  1594.     MyCaos.d1        =(ULONG) name;
  1595.     MyCaos.caos_Un.Offset    =    (-150);
  1596.     MyCaos.a6        =(ULONG) DOSBase;    
  1597.     return((BPTR)PPCCallOS(&MyCaos));
  1598. }
  1599.  
  1600. #define    Lock(name, type)    _Lock(DOS_BASE_NAME, name, type)
  1601.  
  1602. static __inline BPTR
  1603. _Lock(void *DOSBase, STRPTR name, long type)
  1604. {
  1605. struct Caos    MyCaos;
  1606.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1607. //    MyCaos.M68kStart    =    NULL;
  1608. //    MyCaos.M68kSize        =    0;
  1609.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1610. //    MyCaos.PPCStart        =    NULL;
  1611. //    MyCaos.PPCSize        =    0;
  1612.     MyCaos.d1        =(ULONG) name;
  1613.     MyCaos.d2        =(ULONG) type;
  1614.     MyCaos.caos_Un.Offset    =    (-84);
  1615.     MyCaos.a6        =(ULONG) DOSBase;    
  1616.     return((BPTR)PPCCallOS(&MyCaos));
  1617. }
  1618.  
  1619. #define    LockDosList(flags)    _LockDosList(DOS_BASE_NAME, flags)
  1620.  
  1621. static __inline struct DosList *
  1622. _LockDosList(void *DOSBase, unsigned long flags)
  1623. {
  1624. struct Caos    MyCaos;
  1625.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1626. //    MyCaos.M68kStart    =    NULL;
  1627. //    MyCaos.M68kSize        =    0;
  1628.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1629. //    MyCaos.PPCStart        =    NULL;
  1630. //    MyCaos.PPCSize        =    0;
  1631.     MyCaos.d1        =(ULONG) flags;
  1632.     MyCaos.caos_Un.Offset    =    (-654);
  1633.     MyCaos.a6        =(ULONG) DOSBase;    
  1634.     return((struct DosList *)PPCCallOS(&MyCaos));
  1635. }
  1636.  
  1637. #define    LockRecord(fh, offset, length, mode, timeout)    _LockRecord(DOS_BASE_NAME, fh, offset, length, mode, timeout)
  1638.  
  1639. static __inline BOOL
  1640. _LockRecord(void *DOSBase, BPTR fh, unsigned long offset, unsigned long length, unsigned long mode, unsigned long timeout)
  1641. {
  1642. struct Caos    MyCaos;
  1643.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1644. //    MyCaos.M68kStart    =    NULL;
  1645. //    MyCaos.M68kSize        =    0;
  1646.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1647. //    MyCaos.PPCStart        =    NULL;
  1648. //    MyCaos.PPCSize        =    0;
  1649.     MyCaos.d1        =(ULONG) fh;
  1650.     MyCaos.d2        =(ULONG) offset;
  1651.     MyCaos.d3        =(ULONG) length;
  1652.     MyCaos.d4        =(ULONG) mode;
  1653.     MyCaos.d5        =(ULONG) timeout;
  1654.     MyCaos.caos_Un.Offset    =    (-270);
  1655.     MyCaos.a6        =(ULONG) DOSBase;    
  1656.     return((BOOL)PPCCallOS(&MyCaos));
  1657. }
  1658.  
  1659. #define    LockRecords(recArray, timeout)    _LockRecords(DOS_BASE_NAME, recArray, timeout)
  1660.  
  1661. static __inline BOOL
  1662. _LockRecords(void *DOSBase, struct RecordLock *recArray, unsigned long timeout)
  1663. {
  1664. struct Caos    MyCaos;
  1665.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1666. //    MyCaos.M68kStart    =    NULL;
  1667. //    MyCaos.M68kSize        =    0;
  1668.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1669. //    MyCaos.PPCStart        =    NULL;
  1670. //    MyCaos.PPCSize        =    0;
  1671.     MyCaos.d1        =(ULONG) recArray;
  1672.     MyCaos.d2        =(ULONG) timeout;
  1673.     MyCaos.caos_Un.Offset    =    (-276);
  1674.     MyCaos.a6        =(ULONG) DOSBase;    
  1675.     return((BOOL)PPCCallOS(&MyCaos));
  1676. }
  1677.  
  1678. #define    MakeDosEntry(name, type)    _MakeDosEntry(DOS_BASE_NAME, name, type)
  1679.  
  1680. static __inline struct DosList *
  1681. _MakeDosEntry(void *DOSBase, STRPTR name, long type)
  1682. {
  1683. struct Caos    MyCaos;
  1684.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1685. //    MyCaos.M68kStart    =    NULL;
  1686. //    MyCaos.M68kSize        =    0;
  1687.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1688. //    MyCaos.PPCStart        =    NULL;
  1689. //    MyCaos.PPCSize        =    0;
  1690.     MyCaos.d1        =(ULONG) name;
  1691.     MyCaos.d2        =(ULONG) type;
  1692.     MyCaos.caos_Un.Offset    =    (-696);
  1693.     MyCaos.a6        =(ULONG) DOSBase;    
  1694.     return((struct DosList *)PPCCallOS(&MyCaos));
  1695. }
  1696.  
  1697. #define    MakeLink(name, dest, soft)    _MakeLink(DOS_BASE_NAME, name, dest, soft)
  1698.  
  1699. static __inline LONG
  1700. _MakeLink(void *DOSBase, STRPTR name, long dest, long soft)
  1701. {
  1702. struct Caos    MyCaos;
  1703.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1704. //    MyCaos.M68kStart    =    NULL;
  1705. //    MyCaos.M68kSize        =    0;
  1706.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1707. //    MyCaos.PPCStart        =    NULL;
  1708. //    MyCaos.PPCSize        =    0;
  1709.     MyCaos.d1        =(ULONG) name;
  1710.     MyCaos.d2        =(ULONG) dest;
  1711.     MyCaos.d3        =(ULONG) soft;
  1712.     MyCaos.caos_Un.Offset    =    (-444);
  1713.     MyCaos.a6        =(ULONG) DOSBase;    
  1714.     return((LONG)PPCCallOS(&MyCaos));
  1715. }
  1716.  
  1717. #define    MatchEnd(anchor)    _MatchEnd(DOS_BASE_NAME, anchor)
  1718.  
  1719. static __inline void
  1720. _MatchEnd(void *DOSBase, struct AnchorPath *anchor)
  1721. {
  1722. struct Caos    MyCaos;
  1723.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1724. //    MyCaos.M68kStart    =    NULL;
  1725. //    MyCaos.M68kSize        =    0;
  1726.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1727. //    MyCaos.PPCStart        =    NULL;
  1728. //    MyCaos.PPCSize        =    0;
  1729.     MyCaos.d1        =(ULONG) anchor;
  1730.     MyCaos.caos_Un.Offset    =    (-834);
  1731.     MyCaos.a6        =(ULONG) DOSBase;    
  1732.     PPCCallOS(&MyCaos);
  1733. }
  1734.  
  1735. #define    MatchFirst(pat, anchor)    _MatchFirst(DOS_BASE_NAME, pat, anchor)
  1736.  
  1737. static __inline LONG
  1738. _MatchFirst(void *DOSBase, STRPTR pat, struct AnchorPath *anchor)
  1739. {
  1740. struct Caos    MyCaos;
  1741.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1742. //    MyCaos.M68kStart    =    NULL;
  1743. //    MyCaos.M68kSize        =    0;
  1744.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1745. //    MyCaos.PPCStart        =    NULL;
  1746. //    MyCaos.PPCSize        =    0;
  1747.     MyCaos.d1        =(ULONG) pat;
  1748.     MyCaos.d2        =(ULONG) anchor;
  1749.     MyCaos.caos_Un.Offset    =    (-822);
  1750.     MyCaos.a6        =(ULONG) DOSBase;    
  1751.     return((LONG)PPCCallOS(&MyCaos));
  1752. }
  1753.  
  1754. #define    MatchNext(anchor)    _MatchNext(DOS_BASE_NAME, anchor)
  1755.  
  1756. static __inline LONG
  1757. _MatchNext(void *DOSBase, struct AnchorPath *anchor)
  1758. {
  1759. struct Caos    MyCaos;
  1760.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1761. //    MyCaos.M68kStart    =    NULL;
  1762. //    MyCaos.M68kSize        =    0;
  1763.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1764. //    MyCaos.PPCStart        =    NULL;
  1765. //    MyCaos.PPCSize        =    0;
  1766.     MyCaos.d1        =(ULONG) anchor;
  1767.     MyCaos.caos_Un.Offset    =    (-828);
  1768.     MyCaos.a6        =(ULONG) DOSBase;    
  1769.     return((LONG)PPCCallOS(&MyCaos));
  1770. }
  1771.  
  1772. #define    MatchPattern(pat, str)    _MatchPattern(DOS_BASE_NAME, pat, str)
  1773.  
  1774. static __inline BOOL
  1775. _MatchPattern(void *DOSBase, STRPTR pat, STRPTR str)
  1776. {
  1777. struct Caos    MyCaos;
  1778.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1779. //    MyCaos.M68kStart    =    NULL;
  1780. //    MyCaos.M68kSize        =    0;
  1781.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1782. //    MyCaos.PPCStart        =    NULL;
  1783. //    MyCaos.PPCSize        =    0;
  1784.     MyCaos.d1        =(ULONG) pat;
  1785.     MyCaos.d2        =(ULONG) str;
  1786.     MyCaos.caos_Un.Offset    =    (-846);
  1787.     MyCaos.a6        =(ULONG) DOSBase;    
  1788.     return((BOOL)PPCCallOS(&MyCaos));
  1789. }
  1790.  
  1791. #define    MatchPatternNoCase(pat, str)    _MatchPatternNoCase(DOS_BASE_NAME, pat, str)
  1792.  
  1793. static __inline BOOL
  1794. _MatchPatternNoCase(void *DOSBase, STRPTR pat, STRPTR str)
  1795. {
  1796. struct Caos    MyCaos;
  1797.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1798. //    MyCaos.M68kStart    =    NULL;
  1799. //    MyCaos.M68kSize        =    0;
  1800.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1801. //    MyCaos.PPCStart        =    NULL;
  1802. //    MyCaos.PPCSize        =    0;
  1803.     MyCaos.d1        =(ULONG) pat;
  1804.     MyCaos.d2        =(ULONG) str;
  1805.     MyCaos.caos_Un.Offset    =    (-972);
  1806.     MyCaos.a6        =(ULONG) DOSBase;    
  1807.     return((BOOL)PPCCallOS(&MyCaos));
  1808. }
  1809.  
  1810. #define    MaxCli()    _MaxCli(DOS_BASE_NAME)
  1811.  
  1812. static __inline ULONG
  1813. _MaxCli(void *DOSBase)
  1814. {
  1815. struct Caos    MyCaos;
  1816.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1817. //    MyCaos.M68kStart    =    NULL;
  1818. //    MyCaos.M68kSize        =    0;
  1819.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1820. //    MyCaos.PPCStart        =    NULL;
  1821. //    MyCaos.PPCSize        =    0;
  1822.     MyCaos.caos_Un.Offset    =    (-552);
  1823.     MyCaos.a6        =(ULONG) DOSBase;    
  1824.     return((ULONG)PPCCallOS(&MyCaos));
  1825. }
  1826.  
  1827. #define    NameFromFH(fh, buffer, len)    _NameFromFH(DOS_BASE_NAME, fh, buffer, len)
  1828.  
  1829. static __inline LONG
  1830. _NameFromFH(void *DOSBase, BPTR fh, STRPTR buffer, long len)
  1831. {
  1832. struct Caos    MyCaos;
  1833.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1834. //    MyCaos.M68kStart    =    NULL;
  1835. //    MyCaos.M68kSize        =    0;
  1836.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1837. //    MyCaos.PPCStart        =    NULL;
  1838. //    MyCaos.PPCSize        =    0;
  1839.     MyCaos.d1        =(ULONG) fh;
  1840.     MyCaos.d2        =(ULONG) buffer;
  1841.     MyCaos.d3        =(ULONG) len;
  1842.     MyCaos.caos_Un.Offset    =    (-408);
  1843.     MyCaos.a6        =(ULONG) DOSBase;    
  1844.     return((LONG)PPCCallOS(&MyCaos));
  1845. }
  1846.  
  1847. #define    NameFromLock(lock, buffer, len)    _NameFromLock(DOS_BASE_NAME, lock, buffer, len)
  1848.  
  1849. static __inline LONG
  1850. _NameFromLock(void *DOSBase, BPTR lock, STRPTR buffer, long len)
  1851. {
  1852. struct Caos    MyCaos;
  1853.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1854. //    MyCaos.M68kStart    =    NULL;
  1855. //    MyCaos.M68kSize        =    0;
  1856.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1857. //    MyCaos.PPCStart        =    NULL;
  1858. //    MyCaos.PPCSize        =    0;
  1859.     MyCaos.d1        =(ULONG) lock;
  1860.     MyCaos.d2        =(ULONG) buffer;
  1861.     MyCaos.d3        =(ULONG) len;
  1862.     MyCaos.caos_Un.Offset    =    (-402);
  1863.     MyCaos.a6        =(ULONG) DOSBase;    
  1864.     return((LONG)PPCCallOS(&MyCaos));
  1865. }
  1866.  
  1867. #define    NewLoadSeg(file, tags)    _NewLoadSeg(DOS_BASE_NAME, file, tags)
  1868.  
  1869. static __inline BPTR
  1870. _NewLoadSeg(void *DOSBase, STRPTR file, struct TagItem *tags)
  1871. {
  1872. struct Caos    MyCaos;
  1873.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1874. //    MyCaos.M68kStart    =    NULL;
  1875. //    MyCaos.M68kSize        =    0;
  1876.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1877. //    MyCaos.PPCStart        =    NULL;
  1878. //    MyCaos.PPCSize        =    0;
  1879.     MyCaos.d1        =(ULONG) file;
  1880.     MyCaos.d2        =(ULONG) tags;
  1881.     MyCaos.caos_Un.Offset    =    (-768);
  1882.     MyCaos.a6        =(ULONG) DOSBase;    
  1883.     return((BPTR)PPCCallOS(&MyCaos));
  1884. }
  1885.  
  1886. #define NewLoadSegTagList(a0, a1) NewLoadSeg ((a0), (a1))
  1887.  
  1888. #ifndef NO_PPCINLINE_STDARG
  1889. #define NewLoadSegTags(a0, tags...) \
  1890.     ({ULONG _tags[] = { tags }; NewLoadSeg((a0), (struct TagItem *)_tags);})
  1891. #endif /* !NO_PPCINLINE_STDARG */
  1892.  
  1893. #define    NextDosEntry(dlist, flags)    _NextDosEntry(DOS_BASE_NAME, dlist, flags)
  1894.  
  1895. static __inline struct DosList *
  1896. _NextDosEntry(void *DOSBase, struct DosList *dlist, unsigned long flags)
  1897. {
  1898. struct Caos    MyCaos;
  1899.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1900. //    MyCaos.M68kStart    =    NULL;
  1901. //    MyCaos.M68kSize        =    0;
  1902.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1903. //    MyCaos.PPCStart        =    NULL;
  1904. //    MyCaos.PPCSize        =    0;
  1905.     MyCaos.d1        =(ULONG) dlist;
  1906.     MyCaos.d2        =(ULONG) flags;
  1907.     MyCaos.caos_Un.Offset    =    (-690);
  1908.     MyCaos.a6        =(ULONG) DOSBase;    
  1909.     return((struct DosList *)PPCCallOS(&MyCaos));
  1910. }
  1911.  
  1912. #define    Open(name, accessMode)    _Open(DOS_BASE_NAME, name, accessMode)
  1913.  
  1914. static __inline BPTR
  1915. _Open(void *DOSBase, STRPTR name, long accessMode)
  1916. {
  1917. struct Caos    MyCaos;
  1918.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1919. //    MyCaos.M68kStart    =    NULL;
  1920. //    MyCaos.M68kSize        =    0;
  1921.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1922. //    MyCaos.PPCStart        =    NULL;
  1923. //    MyCaos.PPCSize        =    0;
  1924.     MyCaos.d1        =(ULONG) name;
  1925.     MyCaos.d2        =(ULONG) accessMode;
  1926.     MyCaos.caos_Un.Offset    =    (-30);
  1927.     MyCaos.a6        =(ULONG) DOSBase;    
  1928.     return((BPTR)PPCCallOS(&MyCaos));
  1929. }
  1930.  
  1931. #define    OpenFromLock(lock)    _OpenFromLock(DOS_BASE_NAME, lock)
  1932.  
  1933. static __inline BPTR
  1934. _OpenFromLock(void *DOSBase, BPTR lock)
  1935. {
  1936. struct Caos    MyCaos;
  1937.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1938. //    MyCaos.M68kStart    =    NULL;
  1939. //    MyCaos.M68kSize        =    0;
  1940.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1941. //    MyCaos.PPCStart        =    NULL;
  1942. //    MyCaos.PPCSize        =    0;
  1943.     MyCaos.d1        =(ULONG) lock;
  1944.     MyCaos.caos_Un.Offset    =    (-378);
  1945.     MyCaos.a6        =(ULONG) DOSBase;    
  1946.     return((BPTR)PPCCallOS(&MyCaos));
  1947. }
  1948.  
  1949. #define    Output()    _Output(DOS_BASE_NAME)
  1950.  
  1951. static __inline BPTR
  1952. _Output(void *DOSBase)
  1953. {
  1954. struct Caos    MyCaos;
  1955.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1956. //    MyCaos.M68kStart    =    NULL;
  1957. //    MyCaos.M68kSize        =    0;
  1958.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1959. //    MyCaos.PPCStart        =    NULL;
  1960. //    MyCaos.PPCSize        =    0;
  1961.     MyCaos.caos_Un.Offset    =    (-60);
  1962.     MyCaos.a6        =(ULONG) DOSBase;    
  1963.     return((BPTR)PPCCallOS(&MyCaos));
  1964. }
  1965.  
  1966. #define    ParentDir(lock)    _ParentDir(DOS_BASE_NAME, lock)
  1967.  
  1968. static __inline BPTR
  1969. _ParentDir(void *DOSBase, BPTR lock)
  1970. {
  1971. struct Caos    MyCaos;
  1972.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1973. //    MyCaos.M68kStart    =    NULL;
  1974. //    MyCaos.M68kSize        =    0;
  1975.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1976. //    MyCaos.PPCStart        =    NULL;
  1977. //    MyCaos.PPCSize        =    0;
  1978.     MyCaos.d1        =(ULONG) lock;
  1979.     MyCaos.caos_Un.Offset    =    (-210);
  1980.     MyCaos.a6        =(ULONG) DOSBase;    
  1981.     return((BPTR)PPCCallOS(&MyCaos));
  1982. }
  1983.  
  1984. #define    ParentOfFH(fh)    _ParentOfFH(DOS_BASE_NAME, fh)
  1985.  
  1986. static __inline BPTR
  1987. _ParentOfFH(void *DOSBase, BPTR fh)
  1988. {
  1989. struct Caos    MyCaos;
  1990.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1991. //    MyCaos.M68kStart    =    NULL;
  1992. //    MyCaos.M68kSize        =    0;
  1993.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1994. //    MyCaos.PPCStart        =    NULL;
  1995. //    MyCaos.PPCSize        =    0;
  1996.     MyCaos.d1        =(ULONG) fh;
  1997.     MyCaos.caos_Un.Offset    =    (-384);
  1998.     MyCaos.a6        =(ULONG) DOSBase;    
  1999.     return((BPTR)PPCCallOS(&MyCaos));
  2000. }
  2001.  
  2002. #define    ParsePattern(pat, buf, buflen)    _ParsePattern(DOS_BASE_NAME, pat, buf, buflen)
  2003.  
  2004. static __inline LONG
  2005. _ParsePattern(void *DOSBase, STRPTR pat, STRPTR buf, long buflen)
  2006. {
  2007. struct Caos    MyCaos;
  2008.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2009. //    MyCaos.M68kStart    =    NULL;
  2010. //    MyCaos.M68kSize        =    0;
  2011.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2012. //    MyCaos.PPCStart        =    NULL;
  2013. //    MyCaos.PPCSize        =    0;
  2014.     MyCaos.d1        =(ULONG) pat;
  2015.     MyCaos.d2        =(ULONG) buf;
  2016.     MyCaos.d3        =(ULONG) buflen;
  2017.     MyCaos.caos_Un.Offset    =    (-840);
  2018.     MyCaos.a6        =(ULONG) DOSBase;    
  2019.     return((LONG)PPCCallOS(&MyCaos));
  2020. }
  2021.  
  2022. #define    ParsePatternNoCase(pat, buf, buflen)    _ParsePatternNoCase(DOS_BASE_NAME, pat, buf, buflen)
  2023.  
  2024. static __inline LONG
  2025. _ParsePatternNoCase(void *DOSBase, STRPTR pat, STRPTR buf, long buflen)
  2026. {
  2027. struct Caos    MyCaos;
  2028.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2029. //    MyCaos.M68kStart    =    NULL;
  2030. //    MyCaos.M68kSize        =    0;
  2031.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2032. //    MyCaos.PPCStart        =    NULL;
  2033. //    MyCaos.PPCSize        =    0;
  2034.     MyCaos.d1        =(ULONG) pat;
  2035.     MyCaos.d2        =(ULONG) buf;
  2036.     MyCaos.d3        =(ULONG) buflen;
  2037.     MyCaos.caos_Un.Offset    =    (-966);
  2038.     MyCaos.a6        =(ULONG) DOSBase;    
  2039.     return((LONG)PPCCallOS(&MyCaos));
  2040. }
  2041.  
  2042. #define    PathPart(path)    _PathPart(DOS_BASE_NAME, path)
  2043.  
  2044. static __inline STRPTR
  2045. _PathPart(void *DOSBase, STRPTR path)
  2046. {
  2047. struct Caos    MyCaos;
  2048.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2049. //    MyCaos.M68kStart    =    NULL;
  2050. //    MyCaos.M68kSize        =    0;
  2051.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2052. //    MyCaos.PPCStart        =    NULL;
  2053. //    MyCaos.PPCSize        =    0;
  2054.     MyCaos.d1        =(ULONG) path;
  2055.     MyCaos.caos_Un.Offset    =    (-876);
  2056.     MyCaos.a6        =(ULONG) DOSBase;    
  2057.     return((STRPTR)PPCCallOS(&MyCaos));
  2058. }
  2059.  
  2060. #define    PrintFault(code, header)    _PrintFault(DOS_BASE_NAME, code, header)
  2061.  
  2062. static __inline BOOL
  2063. _PrintFault(void *DOSBase, long code, STRPTR header)
  2064. {
  2065. struct Caos    MyCaos;
  2066.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2067. //    MyCaos.M68kStart    =    NULL;
  2068. //    MyCaos.M68kSize        =    0;
  2069.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2070. //    MyCaos.PPCStart        =    NULL;
  2071. //    MyCaos.PPCSize        =    0;
  2072.     MyCaos.d1        =(ULONG) code;
  2073.     MyCaos.d2        =(ULONG) header;
  2074.     MyCaos.caos_Un.Offset    =    (-474);
  2075.     MyCaos.a6        =(ULONG) DOSBase;    
  2076.     return((BOOL)PPCCallOS(&MyCaos));
  2077. }
  2078.  
  2079. #define    PutStr(str)    _PutStr(DOS_BASE_NAME, str)
  2080.  
  2081. static __inline LONG
  2082. _PutStr(void *DOSBase, STRPTR str)
  2083. {
  2084. struct Caos    MyCaos;
  2085.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2086. //    MyCaos.M68kStart    =    NULL;
  2087. //    MyCaos.M68kSize        =    0;
  2088.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2089. //    MyCaos.PPCStart        =    NULL;
  2090. //    MyCaos.PPCSize        =    0;
  2091.     MyCaos.d1        =(ULONG) str;
  2092.     MyCaos.caos_Un.Offset    =    (-948);
  2093.     MyCaos.a6        =(ULONG) DOSBase;    
  2094.     return((LONG)PPCCallOS(&MyCaos));
  2095. }
  2096.  
  2097. #define    Read(file, buffer, length)    _Read(DOS_BASE_NAME, file, buffer, length)
  2098.  
  2099. static __inline LONG
  2100. _Read(void *DOSBase, BPTR file, APTR buffer, long length)
  2101. {
  2102. struct Caos    MyCaos;
  2103.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2104. //    MyCaos.M68kStart    =    NULL;
  2105. //    MyCaos.M68kSize        =    0;
  2106.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2107. //    MyCaos.PPCStart        =    NULL;
  2108. //    MyCaos.PPCSize        =    0;
  2109.     MyCaos.d1        =(ULONG) file;
  2110.     MyCaos.d2        =(ULONG) buffer;
  2111.     MyCaos.d3        =(ULONG) length;
  2112.     MyCaos.caos_Un.Offset    =    (-42);
  2113.     MyCaos.a6        =(ULONG) DOSBase;    
  2114.     return((LONG)PPCCallOS(&MyCaos));
  2115. }
  2116.  
  2117. #define    ReadArgs(arg_template, array, args)    _ReadArgs(DOS_BASE_NAME, arg_template, array, args)
  2118.  
  2119. static __inline struct RDArgs *
  2120. _ReadArgs(void *DOSBase, STRPTR arg_template, LONG *array, struct RDArgs *args)
  2121. {
  2122. struct Caos    MyCaos;
  2123.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2124. //    MyCaos.M68kStart    =    NULL;
  2125. //    MyCaos.M68kSize        =    0;
  2126.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2127. //    MyCaos.PPCStart        =    NULL;
  2128. //    MyCaos.PPCSize        =    0;
  2129.     MyCaos.d1        =(ULONG) arg_template;
  2130.     MyCaos.d2        =(ULONG) array;
  2131.     MyCaos.d3        =(ULONG) args;
  2132.     MyCaos.caos_Un.Offset    =    (-798);
  2133.     MyCaos.a6        =(ULONG) DOSBase;    
  2134.     return((struct RDArgs *)PPCCallOS(&MyCaos));
  2135. }
  2136.  
  2137. #define    ReadItem(name, maxchars, cSource)    _ReadItem(DOS_BASE_NAME, name, maxchars, cSource)
  2138.  
  2139. static __inline LONG
  2140. _ReadItem(void *DOSBase, STRPTR name, long maxchars, struct CSource *cSource)
  2141. {
  2142. struct Caos    MyCaos;
  2143.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2144. //    MyCaos.M68kStart    =    NULL;
  2145. //    MyCaos.M68kSize        =    0;
  2146.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2147. //    MyCaos.PPCStart        =    NULL;
  2148. //    MyCaos.PPCSize        =    0;
  2149.     MyCaos.d1        =(ULONG) name;
  2150.     MyCaos.d2        =(ULONG) maxchars;
  2151.     MyCaos.d3        =(ULONG) cSource;
  2152.     MyCaos.caos_Un.Offset    =    (-810);
  2153.     MyCaos.a6        =(ULONG) DOSBase;    
  2154.     return((LONG)PPCCallOS(&MyCaos));
  2155. }
  2156.  
  2157. #define    ReadLink(port, lock, path, buffer, size)    _ReadLink(DOS_BASE_NAME, port, lock, path, buffer, size)
  2158.  
  2159. static __inline LONG
  2160. _ReadLink(void *DOSBase, struct MsgPort *port, BPTR lock, STRPTR path, STRPTR buffer, unsigned long size)
  2161. {
  2162. struct Caos    MyCaos;
  2163.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2164. //    MyCaos.M68kStart    =    NULL;
  2165. //    MyCaos.M68kSize        =    0;
  2166.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2167. //    MyCaos.PPCStart        =    NULL;
  2168. //    MyCaos.PPCSize        =    0;
  2169.     MyCaos.d1        =(ULONG) port;
  2170.     MyCaos.d2        =(ULONG) lock;
  2171.     MyCaos.d3        =(ULONG) path;
  2172.     MyCaos.d4        =(ULONG) buffer;
  2173.     MyCaos.d5        =(ULONG) size;
  2174.     MyCaos.caos_Un.Offset    =    (-438);
  2175.     MyCaos.a6        =(ULONG) DOSBase;    
  2176.     return((LONG)PPCCallOS(&MyCaos));
  2177. }
  2178.  
  2179. #define    Relabel(drive, newname)    _Relabel(DOS_BASE_NAME, drive, newname)
  2180.  
  2181. static __inline LONG
  2182. _Relabel(void *DOSBase, STRPTR drive, STRPTR newname)
  2183. {
  2184. struct Caos    MyCaos;
  2185.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2186. //    MyCaos.M68kStart    =    NULL;
  2187. //    MyCaos.M68kSize        =    0;
  2188.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2189. //    MyCaos.PPCStart        =    NULL;
  2190. //    MyCaos.PPCSize        =    0;
  2191.     MyCaos.d1        =(ULONG) drive;
  2192.     MyCaos.d2        =(ULONG) newname;
  2193.     MyCaos.caos_Un.Offset    =    (-720);
  2194.     MyCaos.a6        =(ULONG) DOSBase;    
  2195.     return((LONG)PPCCallOS(&MyCaos));
  2196. }
  2197.  
  2198. #define    RemAssignList(name, lock)    _RemAssignList(DOS_BASE_NAME, name, lock)
  2199.  
  2200. static __inline LONG
  2201. _RemAssignList(void *DOSBase, STRPTR name, BPTR lock)
  2202. {
  2203. struct Caos    MyCaos;
  2204.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2205. //    MyCaos.M68kStart    =    NULL;
  2206. //    MyCaos.M68kSize        =    0;
  2207.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2208. //    MyCaos.PPCStart        =    NULL;
  2209. //    MyCaos.PPCSize        =    0;
  2210.     MyCaos.d1        =(ULONG) name;
  2211.     MyCaos.d2        =(ULONG) lock;
  2212.     MyCaos.caos_Un.Offset    =    (-636);
  2213.     MyCaos.a6        =(ULONG) DOSBase;    
  2214.     return((LONG)PPCCallOS(&MyCaos));
  2215. }
  2216.  
  2217. #define    RemDosEntry(dlist)    _RemDosEntry(DOS_BASE_NAME, dlist)
  2218.  
  2219. static __inline BOOL
  2220. _RemDosEntry(void *DOSBase, struct DosList *dlist)
  2221. {
  2222. struct Caos    MyCaos;
  2223.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2224. //    MyCaos.M68kStart    =    NULL;
  2225. //    MyCaos.M68kSize        =    0;
  2226.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2227. //    MyCaos.PPCStart        =    NULL;
  2228. //    MyCaos.PPCSize        =    0;
  2229.     MyCaos.d1        =(ULONG) dlist;
  2230.     MyCaos.caos_Un.Offset    =    (-672);
  2231.     MyCaos.a6        =(ULONG) DOSBase;    
  2232.     return((BOOL)PPCCallOS(&MyCaos));
  2233. }
  2234.  
  2235. #define    RemSegment(seg)    _RemSegment(DOS_BASE_NAME, seg)
  2236.  
  2237. static __inline LONG
  2238. _RemSegment(void *DOSBase, struct Segment *seg)
  2239. {
  2240. struct Caos    MyCaos;
  2241.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2242. //    MyCaos.M68kStart    =    NULL;
  2243. //    MyCaos.M68kSize        =    0;
  2244.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2245. //    MyCaos.PPCStart        =    NULL;
  2246. //    MyCaos.PPCSize        =    0;
  2247.     MyCaos.d1        =(ULONG) seg;
  2248.     MyCaos.caos_Un.Offset    =    (-786);
  2249.     MyCaos.a6        =(ULONG) DOSBase;    
  2250.     return((LONG)PPCCallOS(&MyCaos));
  2251. }
  2252.  
  2253. #define    Rename(oldName, newName)    _Rename(DOS_BASE_NAME, oldName, newName)
  2254.  
  2255. static __inline LONG
  2256. _Rename(void *DOSBase, STRPTR oldName, STRPTR newName)
  2257. {
  2258. struct Caos    MyCaos;
  2259.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2260. //    MyCaos.M68kStart    =    NULL;
  2261. //    MyCaos.M68kSize        =    0;
  2262.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2263. //    MyCaos.PPCStart        =    NULL;
  2264. //    MyCaos.PPCSize        =    0;
  2265.     MyCaos.d1        =(ULONG) oldName;
  2266.     MyCaos.d2        =(ULONG) newName;
  2267.     MyCaos.caos_Un.Offset    =    (-78);
  2268.     MyCaos.a6        =(ULONG) DOSBase;    
  2269.     return((LONG)PPCCallOS(&MyCaos));
  2270. }
  2271.  
  2272. #define    ReplyPkt(dp, res1, res2)    _ReplyPkt(DOS_BASE_NAME, dp, res1, res2)
  2273.  
  2274. static __inline void
  2275. _ReplyPkt(void *DOSBase, struct DosPacket *dp, long res1, long res2)
  2276. {
  2277. struct Caos    MyCaos;
  2278.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2279. //    MyCaos.M68kStart    =    NULL;
  2280. //    MyCaos.M68kSize        =    0;
  2281.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2282. //    MyCaos.PPCStart        =    NULL;
  2283. //    MyCaos.PPCSize        =    0;
  2284.     MyCaos.d1        =(ULONG) dp;
  2285.     MyCaos.d2        =(ULONG) res1;
  2286.     MyCaos.d3        =(ULONG) res2;
  2287.     MyCaos.caos_Un.Offset    =    (-258);
  2288.     MyCaos.a6        =(ULONG) DOSBase;    
  2289.     PPCCallOS(&MyCaos);
  2290. }
  2291.  
  2292. #define    RunCommand(seg, stack, paramptr, paramlen)    _RunCommand(DOS_BASE_NAME, seg, stack, paramptr, paramlen)
  2293.  
  2294. static __inline LONG
  2295. _RunCommand(void *DOSBase, BPTR seg, long stack, STRPTR paramptr, long paramlen)
  2296. {
  2297. struct Caos    MyCaos;
  2298.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2299. //    MyCaos.M68kStart    =    NULL;
  2300. //    MyCaos.M68kSize        =    0;
  2301.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2302. //    MyCaos.PPCStart        =    NULL;
  2303. //    MyCaos.PPCSize        =    0;
  2304.     MyCaos.d1        =(ULONG) seg;
  2305.     MyCaos.d2        =(ULONG) stack;
  2306.     MyCaos.d3        =(ULONG) paramptr;
  2307.     MyCaos.d4        =(ULONG) paramlen;
  2308.     MyCaos.caos_Un.Offset    =    (-504);
  2309.     MyCaos.a6        =(ULONG) DOSBase;    
  2310.     return((LONG)PPCCallOS(&MyCaos));
  2311. }
  2312.  
  2313. #define    SameDevice(lock1, lock2)    _SameDevice(DOS_BASE_NAME, lock1, lock2)
  2314.  
  2315. static __inline BOOL
  2316. _SameDevice(void *DOSBase, BPTR lock1, BPTR lock2)
  2317. {
  2318. struct Caos    MyCaos;
  2319.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2320. //    MyCaos.M68kStart    =    NULL;
  2321. //    MyCaos.M68kSize        =    0;
  2322.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2323. //    MyCaos.PPCStart        =    NULL;
  2324. //    MyCaos.PPCSize        =    0;
  2325.     MyCaos.d1        =(ULONG) lock1;
  2326.     MyCaos.d2        =(ULONG) lock2;
  2327.     MyCaos.caos_Un.Offset    =    (-984);
  2328.     MyCaos.a6        =(ULONG) DOSBase;    
  2329.     return((BOOL)PPCCallOS(&MyCaos));
  2330. }
  2331.  
  2332. #define    SameLock(lock1, lock2)    _SameLock(DOS_BASE_NAME, lock1, lock2)
  2333.  
  2334. static __inline LONG
  2335. _SameLock(void *DOSBase, BPTR lock1, BPTR lock2)
  2336. {
  2337. struct Caos    MyCaos;
  2338.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2339. //    MyCaos.M68kStart    =    NULL;
  2340. //    MyCaos.M68kSize        =    0;
  2341.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2342. //    MyCaos.PPCStart        =    NULL;
  2343. //    MyCaos.PPCSize        =    0;
  2344.     MyCaos.d1        =(ULONG) lock1;
  2345.     MyCaos.d2        =(ULONG) lock2;
  2346.     MyCaos.caos_Un.Offset    =    (-420);
  2347.     MyCaos.a6        =(ULONG) DOSBase;    
  2348.     return((LONG)PPCCallOS(&MyCaos));
  2349. }
  2350.  
  2351. #define    Seek(file, position, offset)    _Seek(DOS_BASE_NAME, file, position, offset)
  2352.  
  2353. static __inline LONG
  2354. _Seek(void *DOSBase, BPTR file, long position, long offset)
  2355. {
  2356. struct Caos    MyCaos;
  2357.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2358. //    MyCaos.M68kStart    =    NULL;
  2359. //    MyCaos.M68kSize        =    0;
  2360.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2361. //    MyCaos.PPCStart        =    NULL;
  2362. //    MyCaos.PPCSize        =    0;
  2363.     MyCaos.d1        =(ULONG) file;
  2364.     MyCaos.d2        =(ULONG) position;
  2365.     MyCaos.d3        =(ULONG) offset;
  2366.     MyCaos.caos_Un.Offset    =    (-66);
  2367.     MyCaos.a6        =(ULONG) DOSBase;    
  2368.     return((LONG)PPCCallOS(&MyCaos));
  2369. }
  2370.  
  2371. #define    SelectInput(fh)    _SelectInput(DOS_BASE_NAME, fh)
  2372.  
  2373. static __inline BPTR
  2374. _SelectInput(void *DOSBase, BPTR fh)
  2375. {
  2376. struct Caos    MyCaos;
  2377.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2378. //    MyCaos.M68kStart    =    NULL;
  2379. //    MyCaos.M68kSize        =    0;
  2380.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2381. //    MyCaos.PPCStart        =    NULL;
  2382. //    MyCaos.PPCSize        =    0;
  2383.     MyCaos.d1        =(ULONG) fh;
  2384.     MyCaos.caos_Un.Offset    =    (-294);
  2385.     MyCaos.a6        =(ULONG) DOSBase;    
  2386.     return((BPTR)PPCCallOS(&MyCaos));
  2387. }
  2388.  
  2389. #define    SelectOutput(fh)    _SelectOutput(DOS_BASE_NAME, fh)
  2390.  
  2391. static __inline BPTR
  2392. _SelectOutput(void *DOSBase, BPTR fh)
  2393. {
  2394. struct Caos    MyCaos;
  2395.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2396. //    MyCaos.M68kStart    =    NULL;
  2397. //    MyCaos.M68kSize        =    0;
  2398.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2399. //    MyCaos.PPCStart        =    NULL;
  2400. //    MyCaos.PPCSize        =    0;
  2401.     MyCaos.d1        =(ULONG) fh;
  2402.     MyCaos.caos_Un.Offset    =    (-300);
  2403.     MyCaos.a6        =(ULONG) DOSBase;    
  2404.     return((BPTR)PPCCallOS(&MyCaos));
  2405. }
  2406.  
  2407. #define    SendPkt(dp, port, replyport)    _SendPkt(DOS_BASE_NAME, dp, port, replyport)
  2408.  
  2409. static __inline void
  2410. _SendPkt(void *DOSBase, struct DosPacket *dp, struct MsgPort *port, struct MsgPort *replyport)
  2411. {
  2412. struct Caos    MyCaos;
  2413.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2414. //    MyCaos.M68kStart    =    NULL;
  2415. //    MyCaos.M68kSize        =    0;
  2416.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2417. //    MyCaos.PPCStart        =    NULL;
  2418. //    MyCaos.PPCSize        =    0;
  2419.     MyCaos.d1        =(ULONG) dp;
  2420.     MyCaos.d2        =(ULONG) port;
  2421.     MyCaos.d3        =(ULONG) replyport;
  2422.     MyCaos.caos_Un.Offset    =    (-246);
  2423.     MyCaos.a6        =(ULONG) DOSBase;    
  2424.     PPCCallOS(&MyCaos);
  2425. }
  2426.  
  2427. #define    SetArgStr(string)    _SetArgStr(DOS_BASE_NAME, string)
  2428.  
  2429. static __inline BOOL
  2430. _SetArgStr(void *DOSBase, STRPTR string)
  2431. {
  2432. struct Caos    MyCaos;
  2433.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2434. //    MyCaos.M68kStart    =    NULL;
  2435. //    MyCaos.M68kSize        =    0;
  2436.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2437. //    MyCaos.PPCStart        =    NULL;
  2438. //    MyCaos.PPCSize        =    0;
  2439.     MyCaos.d1        =(ULONG) string;
  2440.     MyCaos.caos_Un.Offset    =    (-540);
  2441.     MyCaos.a6        =(ULONG) DOSBase;    
  2442.     return((BOOL)PPCCallOS(&MyCaos));
  2443. }
  2444.  
  2445. #define    SetComment(name, comment)    _SetComment(DOS_BASE_NAME, name, comment)
  2446.  
  2447. static __inline LONG
  2448. _SetComment(void *DOSBase, STRPTR name, STRPTR comment)
  2449. {
  2450. struct Caos    MyCaos;
  2451.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2452. //    MyCaos.M68kStart    =    NULL;
  2453. //    MyCaos.M68kSize        =    0;
  2454.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2455. //    MyCaos.PPCStart        =    NULL;
  2456. //    MyCaos.PPCSize        =    0;
  2457.     MyCaos.d1        =(ULONG) name;
  2458.     MyCaos.d2        =(ULONG) comment;
  2459.     MyCaos.caos_Un.Offset    =    (-180);
  2460.     MyCaos.a6        =(ULONG) DOSBase;    
  2461.     return((LONG)PPCCallOS(&MyCaos));
  2462. }
  2463.  
  2464. #define    SetConsoleTask(task)    _SetConsoleTask(DOS_BASE_NAME, task)
  2465.  
  2466. static __inline struct MsgPort *
  2467. _SetConsoleTask(void *DOSBase, struct MsgPort *task)
  2468. {
  2469. struct Caos    MyCaos;
  2470.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2471. //    MyCaos.M68kStart    =    NULL;
  2472. //    MyCaos.M68kSize        =    0;
  2473.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2474. //    MyCaos.PPCStart        =    NULL;
  2475. //    MyCaos.PPCSize        =    0;
  2476.     MyCaos.d1        =(ULONG) task;
  2477.     MyCaos.caos_Un.Offset    =    (-516);
  2478.     MyCaos.a6        =(ULONG) DOSBase;    
  2479.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  2480. }
  2481.  
  2482. #define    SetCurrentDirName(name)    _SetCurrentDirName(DOS_BASE_NAME, name)
  2483.  
  2484. static __inline BOOL
  2485. _SetCurrentDirName(void *DOSBase, STRPTR name)
  2486. {
  2487. struct Caos    MyCaos;
  2488.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2489. //    MyCaos.M68kStart    =    NULL;
  2490. //    MyCaos.M68kSize        =    0;
  2491.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2492. //    MyCaos.PPCStart        =    NULL;
  2493. //    MyCaos.PPCSize        =    0;
  2494.     MyCaos.d1        =(ULONG) name;
  2495.     MyCaos.caos_Un.Offset    =    (-558);
  2496.     MyCaos.a6        =(ULONG) DOSBase;    
  2497.     return((BOOL)PPCCallOS(&MyCaos));
  2498. }
  2499.  
  2500. #define    SetFileDate(name, date)    _SetFileDate(DOS_BASE_NAME, name, date)
  2501.  
  2502. static __inline LONG
  2503. _SetFileDate(void *DOSBase, STRPTR name, struct DateStamp *date)
  2504. {
  2505. struct Caos    MyCaos;
  2506.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2507. //    MyCaos.M68kStart    =    NULL;
  2508. //    MyCaos.M68kSize        =    0;
  2509.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2510. //    MyCaos.PPCStart        =    NULL;
  2511. //    MyCaos.PPCSize        =    0;
  2512.     MyCaos.d1        =(ULONG) name;
  2513.     MyCaos.d2        =(ULONG) date;
  2514.     MyCaos.caos_Un.Offset    =    (-396);
  2515.     MyCaos.a6        =(ULONG) DOSBase;    
  2516.     return((LONG)PPCCallOS(&MyCaos));
  2517. }
  2518.  
  2519. #define    SetFileSize(fh, pos, mode)    _SetFileSize(DOS_BASE_NAME, fh, pos, mode)
  2520.  
  2521. static __inline LONG
  2522. _SetFileSize(void *DOSBase, BPTR fh, long pos, long mode)
  2523. {
  2524. struct Caos    MyCaos;
  2525.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2526. //    MyCaos.M68kStart    =    NULL;
  2527. //    MyCaos.M68kSize        =    0;
  2528.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2529. //    MyCaos.PPCStart        =    NULL;
  2530. //    MyCaos.PPCSize        =    0;
  2531.     MyCaos.d1        =(ULONG) fh;
  2532.     MyCaos.d2        =(ULONG) pos;
  2533.     MyCaos.d3        =(ULONG) mode;
  2534.     MyCaos.caos_Un.Offset    =    (-456);
  2535.     MyCaos.a6        =(ULONG) DOSBase;    
  2536.     return((LONG)PPCCallOS(&MyCaos));
  2537. }
  2538.  
  2539. #define    SetFileSysTask(task)    _SetFileSysTask(DOS_BASE_NAME, task)
  2540.  
  2541. static __inline struct MsgPort *
  2542. _SetFileSysTask(void *DOSBase, struct MsgPort *task)
  2543. {
  2544. struct Caos    MyCaos;
  2545.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2546. //    MyCaos.M68kStart    =    NULL;
  2547. //    MyCaos.M68kSize        =    0;
  2548.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2549. //    MyCaos.PPCStart        =    NULL;
  2550. //    MyCaos.PPCSize        =    0;
  2551.     MyCaos.d1        =(ULONG) task;
  2552.     MyCaos.caos_Un.Offset    =    (-528);
  2553.     MyCaos.a6        =(ULONG) DOSBase;    
  2554.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  2555. }
  2556.  
  2557. #define    SetIoErr(result)    _SetIoErr(DOS_BASE_NAME, result)
  2558.  
  2559. static __inline LONG
  2560. _SetIoErr(void *DOSBase, long result)
  2561. {
  2562. struct Caos    MyCaos;
  2563.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2564. //    MyCaos.M68kStart    =    NULL;
  2565. //    MyCaos.M68kSize        =    0;
  2566.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2567. //    MyCaos.PPCStart        =    NULL;
  2568. //    MyCaos.PPCSize        =    0;
  2569.     MyCaos.d1        =(ULONG) result;
  2570.     MyCaos.caos_Un.Offset    =    (-462);
  2571.     MyCaos.a6        =(ULONG) DOSBase;    
  2572.     return((LONG)PPCCallOS(&MyCaos));
  2573. }
  2574.  
  2575. #define    SetMode(fh, mode)    _SetMode(DOS_BASE_NAME, fh, mode)
  2576.  
  2577. static __inline LONG
  2578. _SetMode(void *DOSBase, BPTR fh, long mode)
  2579. {
  2580. struct Caos    MyCaos;
  2581.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2582. //    MyCaos.M68kStart    =    NULL;
  2583. //    MyCaos.M68kSize        =    0;
  2584.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2585. //    MyCaos.PPCStart        =    NULL;
  2586. //    MyCaos.PPCSize        =    0;
  2587.     MyCaos.d1        =(ULONG) fh;
  2588.     MyCaos.d2        =(ULONG) mode;
  2589.     MyCaos.caos_Un.Offset    =    (-426);
  2590.     MyCaos.a6        =(ULONG) DOSBase;    
  2591.     return((LONG)PPCCallOS(&MyCaos));
  2592. }
  2593.  
  2594. #define    SetOwner(name, owner_info)    _SetOwner(DOS_BASE_NAME, name, owner_info)
  2595.  
  2596. static __inline BOOL
  2597. _SetOwner(void *DOSBase, STRPTR name, long owner_info)
  2598. {
  2599. struct Caos    MyCaos;
  2600.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2601. //    MyCaos.M68kStart    =    NULL;
  2602. //    MyCaos.M68kSize        =    0;
  2603.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2604. //    MyCaos.PPCStart        =    NULL;
  2605. //    MyCaos.PPCSize        =    0;
  2606.     MyCaos.d1        =(ULONG) name;
  2607.     MyCaos.d2        =(ULONG) owner_info;
  2608.     MyCaos.caos_Un.Offset    =    (-996);
  2609.     MyCaos.a6        =(ULONG) DOSBase;    
  2610.     return((BOOL)PPCCallOS(&MyCaos));
  2611. }
  2612.  
  2613. #define    SetProgramDir(lock)    _SetProgramDir(DOS_BASE_NAME, lock)
  2614.  
  2615. static __inline BPTR
  2616. _SetProgramDir(void *DOSBase, BPTR lock)
  2617. {
  2618. struct Caos    MyCaos;
  2619.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2620. //    MyCaos.M68kStart    =    NULL;
  2621. //    MyCaos.M68kSize        =    0;
  2622.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2623. //    MyCaos.PPCStart        =    NULL;
  2624. //    MyCaos.PPCSize        =    0;
  2625.     MyCaos.d1        =(ULONG) lock;
  2626.     MyCaos.caos_Un.Offset    =    (-594);
  2627.     MyCaos.a6        =(ULONG) DOSBase;    
  2628.     return((BPTR)PPCCallOS(&MyCaos));
  2629. }
  2630.  
  2631. #define    SetProgramName(name)    _SetProgramName(DOS_BASE_NAME, name)
  2632.  
  2633. static __inline BOOL
  2634. _SetProgramName(void *DOSBase, STRPTR name)
  2635. {
  2636. struct Caos    MyCaos;
  2637.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2638. //    MyCaos.M68kStart    =    NULL;
  2639. //    MyCaos.M68kSize        =    0;
  2640.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2641. //    MyCaos.PPCStart        =    NULL;
  2642. //    MyCaos.PPCSize        =    0;
  2643.     MyCaos.d1        =(ULONG) name;
  2644.     MyCaos.caos_Un.Offset    =    (-570);
  2645.     MyCaos.a6        =(ULONG) DOSBase;    
  2646.     return((BOOL)PPCCallOS(&MyCaos));
  2647. }
  2648.  
  2649. #define    SetPrompt(name)    _SetPrompt(DOS_BASE_NAME, name)
  2650.  
  2651. static __inline BOOL
  2652. _SetPrompt(void *DOSBase, STRPTR name)
  2653. {
  2654. struct Caos    MyCaos;
  2655.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2656. //    MyCaos.M68kStart    =    NULL;
  2657. //    MyCaos.M68kSize        =    0;
  2658.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2659. //    MyCaos.PPCStart        =    NULL;
  2660. //    MyCaos.PPCSize        =    0;
  2661.     MyCaos.d1        =(ULONG) name;
  2662.     MyCaos.caos_Un.Offset    =    (-582);
  2663.     MyCaos.a6        =(ULONG) DOSBase;    
  2664.     return((BOOL)PPCCallOS(&MyCaos));
  2665. }
  2666.  
  2667. #define    SetProtection(name, protect)    _SetProtection(DOS_BASE_NAME, name, protect)
  2668.  
  2669. static __inline LONG
  2670. _SetProtection(void *DOSBase, STRPTR name, long protect)
  2671. {
  2672. struct Caos    MyCaos;
  2673.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2674. //    MyCaos.M68kStart    =    NULL;
  2675. //    MyCaos.M68kSize        =    0;
  2676.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2677. //    MyCaos.PPCStart        =    NULL;
  2678. //    MyCaos.PPCSize        =    0;
  2679.     MyCaos.d1        =(ULONG) name;
  2680.     MyCaos.d2        =(ULONG) protect;
  2681.     MyCaos.caos_Un.Offset    =    (-186);
  2682.     MyCaos.a6        =(ULONG) DOSBase;    
  2683.     return((LONG)PPCCallOS(&MyCaos));
  2684. }
  2685.  
  2686. #define    SetVBuf(fh, buff, type, size)    _SetVBuf(DOS_BASE_NAME, fh, buff, type, size)
  2687.  
  2688. static __inline LONG
  2689. _SetVBuf(void *DOSBase, BPTR fh, STRPTR buff, long type, long size)
  2690. {
  2691. struct Caos    MyCaos;
  2692.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2693. //    MyCaos.M68kStart    =    NULL;
  2694. //    MyCaos.M68kSize        =    0;
  2695.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2696. //    MyCaos.PPCStart        =    NULL;
  2697. //    MyCaos.PPCSize        =    0;
  2698.     MyCaos.d1        =(ULONG) fh;
  2699.     MyCaos.d2        =(ULONG) buff;
  2700.     MyCaos.d3        =(ULONG) type;
  2701.     MyCaos.d4        =(ULONG) size;
  2702.     MyCaos.caos_Un.Offset    =    (-366);
  2703.     MyCaos.a6        =(ULONG) DOSBase;    
  2704.     return((LONG)PPCCallOS(&MyCaos));
  2705. }
  2706.  
  2707. #define    SetVar(name, buffer, size, flags)    _SetVar(DOS_BASE_NAME, name, buffer, size, flags)
  2708.  
  2709. static __inline BOOL
  2710. _SetVar(void *DOSBase, STRPTR name, STRPTR buffer, long size, long flags)
  2711. {
  2712. struct Caos    MyCaos;
  2713.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2714. //    MyCaos.M68kStart    =    NULL;
  2715. //    MyCaos.M68kSize        =    0;
  2716.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2717. //    MyCaos.PPCStart        =    NULL;
  2718. //    MyCaos.PPCSize        =    0;
  2719.     MyCaos.d1        =(ULONG) name;
  2720.     MyCaos.d2        =(ULONG) buffer;
  2721.     MyCaos.d3        =(ULONG) size;
  2722.     MyCaos.d4        =(ULONG) flags;
  2723.     MyCaos.caos_Un.Offset    =    (-900);
  2724.     MyCaos.a6        =(ULONG) DOSBase;    
  2725.     return((BOOL)PPCCallOS(&MyCaos));
  2726. }
  2727.  
  2728. #define    SplitName(name, seperator, buf, oldpos, size)    _SplitName(DOS_BASE_NAME, name, seperator, buf, oldpos, size)
  2729.  
  2730. static __inline WORD
  2731. _SplitName(void *DOSBase, STRPTR name, unsigned long seperator, STRPTR buf, long oldpos, long size)
  2732. {
  2733. struct Caos    MyCaos;
  2734.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2735. //    MyCaos.M68kStart    =    NULL;
  2736. //    MyCaos.M68kSize        =    0;
  2737.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2738. //    MyCaos.PPCStart        =    NULL;
  2739. //    MyCaos.PPCSize        =    0;
  2740.     MyCaos.d1        =(ULONG) name;
  2741.     MyCaos.d2        =(ULONG) seperator;
  2742.     MyCaos.d3        =(ULONG) buf;
  2743.     MyCaos.d4        =(ULONG) oldpos;
  2744.     MyCaos.d5        =(ULONG) size;
  2745.     MyCaos.caos_Un.Offset    =    (-414);
  2746.     MyCaos.a6        =(ULONG) DOSBase;    
  2747.     return((WORD)PPCCallOS(&MyCaos));
  2748. }
  2749.  
  2750. #define    StartNotify(notify)    _StartNotify(DOS_BASE_NAME, notify)
  2751.  
  2752. static __inline BOOL
  2753. _StartNotify(void *DOSBase, struct NotifyRequest *notify)
  2754. {
  2755. struct Caos    MyCaos;
  2756.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2757. //    MyCaos.M68kStart    =    NULL;
  2758. //    MyCaos.M68kSize        =    0;
  2759.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2760. //    MyCaos.PPCStart        =    NULL;
  2761. //    MyCaos.PPCSize        =    0;
  2762.     MyCaos.d1        =(ULONG) notify;
  2763.     MyCaos.caos_Un.Offset    =    (-888);
  2764.     MyCaos.a6        =(ULONG) DOSBase;    
  2765.     return((BOOL)PPCCallOS(&MyCaos));
  2766. }
  2767.  
  2768. #define    StrToDate(datetime)    _StrToDate(DOS_BASE_NAME, datetime)
  2769.  
  2770. static __inline LONG
  2771. _StrToDate(void *DOSBase, struct DateTime *datetime)
  2772. {
  2773. struct Caos    MyCaos;
  2774.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2775. //    MyCaos.M68kStart    =    NULL;
  2776. //    MyCaos.M68kSize        =    0;
  2777.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2778. //    MyCaos.PPCStart        =    NULL;
  2779. //    MyCaos.PPCSize        =    0;
  2780.     MyCaos.d1        =(ULONG) datetime;
  2781.     MyCaos.caos_Un.Offset    =    (-750);
  2782.     MyCaos.a6        =(ULONG) DOSBase;    
  2783.     return((LONG)PPCCallOS(&MyCaos));
  2784. }
  2785.  
  2786. #define    StrToLong(string, value)    _StrToLong(DOS_BASE_NAME, string, value)
  2787.  
  2788. static __inline LONG
  2789. _StrToLong(void *DOSBase, STRPTR string, LONG *value)
  2790. {
  2791. struct Caos    MyCaos;
  2792.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2793. //    MyCaos.M68kStart    =    NULL;
  2794. //    MyCaos.M68kSize        =    0;
  2795.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2796. //    MyCaos.PPCStart        =    NULL;
  2797. //    MyCaos.PPCSize        =    0;
  2798.     MyCaos.d1        =(ULONG) string;
  2799.     MyCaos.d2        =(ULONG) value;
  2800.     MyCaos.caos_Un.Offset    =    (-816);
  2801.     MyCaos.a6        =(ULONG) DOSBase;    
  2802.     return((LONG)PPCCallOS(&MyCaos));
  2803. }
  2804.  
  2805. #define    SystemTagList(command, tags)    _SystemTagList(DOS_BASE_NAME, command, tags)
  2806.  
  2807. static __inline LONG
  2808. _SystemTagList(void *DOSBase, STRPTR command, struct TagItem *tags)
  2809. {
  2810. struct Caos    MyCaos;
  2811.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2812. //    MyCaos.M68kStart    =    NULL;
  2813. //    MyCaos.M68kSize        =    0;
  2814.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2815. //    MyCaos.PPCStart        =    NULL;
  2816. //    MyCaos.PPCSize        =    0;
  2817.     MyCaos.d1        =(ULONG) command;
  2818.     MyCaos.d2        =(ULONG) tags;
  2819.     MyCaos.caos_Un.Offset    =    (-606);
  2820.     MyCaos.a6        =(ULONG) DOSBase;    
  2821.     return((LONG)PPCCallOS(&MyCaos));
  2822. }
  2823.  
  2824. #define System(a0, a1) SystemTagList ((a0), (a1))
  2825.  
  2826. #ifndef NO_PPCINLINE_STDARG
  2827. #define SystemTags(a0, tags...) \
  2828.     ({ULONG _tags[] = { tags }; SystemTagList((a0), (struct TagItem *)_tags);})
  2829. #endif /* !NO_PPCINLINE_STDARG */
  2830.  
  2831. #define    UnGetC(fh, character)    _UnGetC(DOS_BASE_NAME, fh, character)
  2832.  
  2833. static __inline LONG
  2834. _UnGetC(void *DOSBase, BPTR fh, long character)
  2835. {
  2836. struct Caos    MyCaos;
  2837.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2838. //    MyCaos.M68kStart    =    NULL;
  2839. //    MyCaos.M68kSize        =    0;
  2840.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2841. //    MyCaos.PPCStart        =    NULL;
  2842. //    MyCaos.PPCSize        =    0;
  2843.     MyCaos.d1        =(ULONG) fh;
  2844.     MyCaos.d2        =(ULONG) character;
  2845.     MyCaos.caos_Un.Offset    =    (-318);
  2846.     MyCaos.a6        =(ULONG) DOSBase;    
  2847.     return((LONG)PPCCallOS(&MyCaos));
  2848. }
  2849.  
  2850. #define    UnLoadSeg(seglist)    _UnLoadSeg(DOS_BASE_NAME, seglist)
  2851.  
  2852. static __inline void
  2853. _UnLoadSeg(void *DOSBase, BPTR seglist)
  2854. {
  2855. struct Caos    MyCaos;
  2856.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2857. //    MyCaos.M68kStart    =    NULL;
  2858. //    MyCaos.M68kSize        =    0;
  2859.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2860. //    MyCaos.PPCStart        =    NULL;
  2861. //    MyCaos.PPCSize        =    0;
  2862.     MyCaos.d1        =(ULONG) seglist;
  2863.     MyCaos.caos_Un.Offset    =    (-156);
  2864.     MyCaos.a6        =(ULONG) DOSBase;    
  2865.     PPCCallOS(&MyCaos);
  2866. }
  2867.  
  2868. #define    UnLock(lock)    _UnLock(DOS_BASE_NAME, lock)
  2869.  
  2870. static __inline void
  2871. _UnLock(void *DOSBase, BPTR lock)
  2872. {
  2873. struct Caos    MyCaos;
  2874.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2875. //    MyCaos.M68kStart    =    NULL;
  2876. //    MyCaos.M68kSize        =    0;
  2877.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2878. //    MyCaos.PPCStart        =    NULL;
  2879. //    MyCaos.PPCSize        =    0;
  2880.     MyCaos.d1        =(ULONG) lock;
  2881.     MyCaos.caos_Un.Offset    =    (-90);
  2882.     MyCaos.a6        =(ULONG) DOSBase;    
  2883.     PPCCallOS(&MyCaos);
  2884. }
  2885.  
  2886. #define    UnLockDosList(flags)    _UnLockDosList(DOS_BASE_NAME, flags)
  2887.  
  2888. static __inline void
  2889. _UnLockDosList(void *DOSBase, unsigned long flags)
  2890. {
  2891. struct Caos    MyCaos;
  2892.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2893. //    MyCaos.M68kStart    =    NULL;
  2894. //    MyCaos.M68kSize        =    0;
  2895.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2896. //    MyCaos.PPCStart        =    NULL;
  2897. //    MyCaos.PPCSize        =    0;
  2898.     MyCaos.d1        =(ULONG) flags;
  2899.     MyCaos.caos_Un.Offset    =    (-660);
  2900.     MyCaos.a6        =(ULONG) DOSBase;    
  2901.     PPCCallOS(&MyCaos);
  2902. }
  2903.  
  2904. #define    UnLockRecord(fh, offset, length)    _UnLockRecord(DOS_BASE_NAME, fh, offset, length)
  2905.  
  2906. static __inline BOOL
  2907. _UnLockRecord(void *DOSBase, BPTR fh, unsigned long offset, unsigned long length)
  2908. {
  2909. struct Caos    MyCaos;
  2910.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2911. //    MyCaos.M68kStart    =    NULL;
  2912. //    MyCaos.M68kSize        =    0;
  2913.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2914. //    MyCaos.PPCStart        =    NULL;
  2915. //    MyCaos.PPCSize        =    0;
  2916.     MyCaos.d1        =(ULONG) fh;
  2917.     MyCaos.d2        =(ULONG) offset;
  2918.     MyCaos.d3        =(ULONG) length;
  2919.     MyCaos.caos_Un.Offset    =    (-282);
  2920.     MyCaos.a6        =(ULONG) DOSBase;    
  2921.     return((BOOL)PPCCallOS(&MyCaos));
  2922. }
  2923.  
  2924. #define    UnLockRecords(recArray)    _UnLockRecords(DOS_BASE_NAME, recArray)
  2925.  
  2926. static __inline BOOL
  2927. _UnLockRecords(void *DOSBase, struct RecordLock *recArray)
  2928. {
  2929. struct Caos    MyCaos;
  2930.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2931. //    MyCaos.M68kStart    =    NULL;
  2932. //    MyCaos.M68kSize        =    0;
  2933.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2934. //    MyCaos.PPCStart        =    NULL;
  2935. //    MyCaos.PPCSize        =    0;
  2936.     MyCaos.d1        =(ULONG) recArray;
  2937.     MyCaos.caos_Un.Offset    =    (-288);
  2938.     MyCaos.a6        =(ULONG) DOSBase;    
  2939.     return((BOOL)PPCCallOS(&MyCaos));
  2940. }
  2941.  
  2942. #define    VFPrintf(fh, format, argarray)    _VFPrintf(DOS_BASE_NAME, fh, format, argarray)
  2943.  
  2944. static __inline LONG
  2945. _VFPrintf(void *DOSBase, BPTR fh, STRPTR format, APTR argarray)
  2946. {
  2947. struct Caos    MyCaos;
  2948.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2949. //    MyCaos.M68kStart    =    NULL;
  2950. //    MyCaos.M68kSize        =    0;
  2951.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2952. //    MyCaos.PPCStart        =    NULL;
  2953. //    MyCaos.PPCSize        =    0;
  2954.     MyCaos.d1        =(ULONG) fh;
  2955.     MyCaos.d2        =(ULONG) format;
  2956.     MyCaos.d3        =(ULONG) argarray;
  2957.     MyCaos.caos_Un.Offset    =    (-354);
  2958.     MyCaos.a6        =(ULONG) DOSBase;    
  2959.     return((LONG)PPCCallOS(&MyCaos));
  2960. }
  2961.  
  2962. #ifndef NO_PPCINLINE_STDARG
  2963. #define FPrintf(a0, a1, tags...) \
  2964.     ({ULONG _tags[] = { tags }; VFPrintf((a0), (a1), (APTR)_tags);})
  2965. #endif /* !NO_PPCINLINE_STDARG */
  2966.  
  2967. #define    VFWritef(fh, format, argarray)    _VFWritef(DOS_BASE_NAME, fh, format, argarray)
  2968.  
  2969. static __inline void
  2970. _VFWritef(void *DOSBase, BPTR fh, STRPTR format, LONG *argarray)
  2971. {
  2972. struct Caos    MyCaos;
  2973.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2974. //    MyCaos.M68kStart    =    NULL;
  2975. //    MyCaos.M68kSize        =    0;
  2976.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2977. //    MyCaos.PPCStart        =    NULL;
  2978. //    MyCaos.PPCSize        =    0;
  2979.     MyCaos.d1        =(ULONG) fh;
  2980.     MyCaos.d2        =(ULONG) format;
  2981.     MyCaos.d3        =(ULONG) argarray;
  2982.     MyCaos.caos_Un.Offset    =    (-348);
  2983.     MyCaos.a6        =(ULONG) DOSBase;    
  2984.     PPCCallOS(&MyCaos);
  2985. }
  2986.  
  2987. #ifndef NO_PPCINLINE_STDARG
  2988. #define FWritef(a0, a1, tags...) \
  2989.     ({ULONG _tags[] = { tags }; VFWritef((a0), (a1), (LONG *)_tags);})
  2990. #endif /* !NO_PPCINLINE_STDARG */
  2991.  
  2992. #define    VPrintf(format, argarray)    _VPrintf(DOS_BASE_NAME, format, argarray)
  2993.  
  2994. static __inline LONG
  2995. _VPrintf(void *DOSBase, STRPTR format, APTR argarray)
  2996. {
  2997. struct Caos    MyCaos;
  2998.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2999. //    MyCaos.M68kStart    =    NULL;
  3000. //    MyCaos.M68kSize        =    0;
  3001.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3002. //    MyCaos.PPCStart        =    NULL;
  3003. //    MyCaos.PPCSize        =    0;
  3004.     MyCaos.d1        =(ULONG) format;
  3005.     MyCaos.d2        =(ULONG) argarray;
  3006.     MyCaos.caos_Un.Offset    =    (-954);
  3007.     MyCaos.a6        =(ULONG) DOSBase;    
  3008.     return((LONG)PPCCallOS(&MyCaos));
  3009. }
  3010.  
  3011. #ifndef NO_PPCINLINE_STDARG
  3012. #define Printf(a0, tags...) \
  3013.     ({ULONG _tags[] = { tags }; VPrintf((a0), (APTR)_tags);})
  3014. #endif /* !NO_PPCINLINE_STDARG */
  3015.  
  3016. #define    WaitForChar(file, timeout)    _WaitForChar(DOS_BASE_NAME, file, timeout)
  3017.  
  3018. static __inline LONG
  3019. _WaitForChar(void *DOSBase, BPTR file, long timeout)
  3020. {
  3021. struct Caos    MyCaos;
  3022.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3023. //    MyCaos.M68kStart    =    NULL;
  3024. //    MyCaos.M68kSize        =    0;
  3025.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3026. //    MyCaos.PPCStart        =    NULL;
  3027. //    MyCaos.PPCSize        =    0;
  3028.     MyCaos.d1        =(ULONG) file;
  3029.     MyCaos.d2        =(ULONG) timeout;
  3030.     MyCaos.caos_Un.Offset    =    (-204);
  3031.     MyCaos.a6        =(ULONG) DOSBase;    
  3032.     return((LONG)PPCCallOS(&MyCaos));
  3033. }
  3034.  
  3035. #define    WaitPkt()    _WaitPkt(DOS_BASE_NAME)
  3036.  
  3037. static __inline struct DosPacket *
  3038. _WaitPkt(void *DOSBase)
  3039. {
  3040. struct Caos    MyCaos;
  3041.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3042. //    MyCaos.M68kStart    =    NULL;
  3043. //    MyCaos.M68kSize        =    0;
  3044.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3045. //    MyCaos.PPCStart        =    NULL;
  3046. //    MyCaos.PPCSize        =    0;
  3047.     MyCaos.caos_Un.Offset    =    (-252);
  3048.     MyCaos.a6        =(ULONG) DOSBase;    
  3049.     return((struct DosPacket *)PPCCallOS(&MyCaos));
  3050. }
  3051.  
  3052. #define    Write(file, buffer, length)    _Write(DOS_BASE_NAME, file, buffer, length)
  3053.  
  3054. static __inline LONG
  3055. _Write(void *DOSBase, BPTR file, APTR buffer, long length)
  3056. {
  3057. struct Caos    MyCaos;
  3058.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3059. //    MyCaos.M68kStart    =    NULL;
  3060. //    MyCaos.M68kSize        =    0;
  3061.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3062. //    MyCaos.PPCStart        =    NULL;
  3063. //    MyCaos.PPCSize        =    0;
  3064.     MyCaos.d1        =(ULONG) file;
  3065.     MyCaos.d2        =(ULONG) buffer;
  3066.     MyCaos.d3        =(ULONG) length;
  3067.     MyCaos.caos_Un.Offset    =    (-48);
  3068.     MyCaos.a6        =(ULONG) DOSBase;    
  3069.     return((LONG)PPCCallOS(&MyCaos));
  3070. }
  3071.  
  3072. #define    WriteChars(buf, buflen)    _WriteChars(DOS_BASE_NAME, buf, buflen)
  3073.  
  3074. static __inline LONG
  3075. _WriteChars(void *DOSBase, STRPTR buf, unsigned long buflen)
  3076. {
  3077. struct Caos    MyCaos;
  3078.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3079. //    MyCaos.M68kStart    =    NULL;
  3080. //    MyCaos.M68kSize        =    0;
  3081.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3082. //    MyCaos.PPCStart        =    NULL;
  3083. //    MyCaos.PPCSize        =    0;
  3084.     MyCaos.d1        =(ULONG) buf;
  3085.     MyCaos.d2        =(ULONG) buflen;
  3086.     MyCaos.caos_Un.Offset    =    (-942);
  3087.     MyCaos.a6        =(ULONG) DOSBase;    
  3088.     return((LONG)PPCCallOS(&MyCaos));
  3089. }
  3090.  
  3091. #endif /* SASC Pragmas */
  3092. #endif /* !_PPCPRAGMA_DOS_H */
  3093.